Introduction détaillée au multi-processus en python (exemple de code)

Le contenu de cet article est une introduction détaillée (exemple de code) sur le multi-processus en Python. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Cette section parle de l'apprentissage du multi-processus de Python.

1. Comparaison entre multi-processus et multi-threading

Multi-processus Multiprocessing est similaire au multi-threading Ils sont tous deux utilisés pour les opérations 并行 en python. qu'il y a du threading, pourquoi Python a-t-il un multitraitement ? La raison est très simple, c'est pour compenser certains inconvénients du threading, comme mentionné dans le tutoriel sur le threading GIL.

Utiliser le multitraitement est. C'est aussi très simple. Amis qui ont une certaine compréhension, votre moment est venu d'en profiter. Parce que python rend l'utilisation du multitraitement et du threading presque la même, cela nous permet également de démarrer plus facilement. le système multicœur de votre ordinateur !

2. Ajouter un processus Processus

import multiprocessing as mp
import threading as td

def job(a,d):
    print('aaaaa')

t1 = td.Thread(target=job,args=(1,2))
p1 = mp.Process(target=job,args=(1,2))
t1.start()
p1.start()
t1.join()
p1.join()

Comme le montre le code de comparaison d'utilisation ci-dessus, les threads et les processus sont utilisés de manière similaire.

Lors de l'utilisation de

, vous devez ajouter une instruction définissant la fonction principale

if __name__=='__main__':

Code d'application complet :

# -*- coding:utf-8 -*-

"""
@author: Corwien
@file: process_test.py
@time: 18/8/26 01:12
"""

import multiprocessing as mp

def job(a, d):
    print a, d

if __name__ == '__main__':
    p1 = mp.Process(target=job, args=(1, 2))
    p1.start()
    p1.join()

Environnement d'exécution Dans un Dans l'environnement du terminal, d'autres outils d'édition peuvent ne pas imprimer les résultats après l'exécution. Les résultats imprimés après l'exécution dans le terminal sont :

➜  baseLearn python ./process/process_test.py
1 2
➜  baseLearn

3. File d'attente de sortie du processus stocké

La fonction de la file d'attente est de placez les résultats de l'opération de chaque cœur ou thread dans la file d'attente, attendez que chaque thread ou cœur ait fini de s'exécuter, puis retirez les résultats de la file d'attente et continuez à charger l'opération. La raison est très simple. Les fonctions appelées par plusieurs threads ne peuvent pas avoir de valeur de retour, donc la file d'attente est utilisée pour stocker les résultats de plusieurs opérations de thread

process_queue.py

# -*- coding:utf-8 -*-

"""
@author: Corwien
@file: process_queue.py
@time: 18/8/26 01:12
"""

import multiprocessing as mp

# 定义一个被多线程调用的函数，q 就像一个队列，用来保存每次函数运行的结果
def job(q):
    res = 0
    for i in range(1000):
        res += i + i**2 + i**3
    q.put(res)   #queue

if __name__ == '__main__':
    q = mp.Queue()
    p1 = mp.Process(target=job, args=(q,))
    p2 = mp.Process(target=job, args=(q,))

    # 分别启动、连接两个线程
    p1.start()
    p2.start()
    p1.join()
    p2.join()

    # 上面是分两批处理的，所以这里分两批输出，将结果分别保存
    res1 = q.get()
    res2 = q.get()

    print res1,res2

Imprimer la sortie. résultat :

➜ python ./process/process_queue.py
249833583000 249833583000

4. Pool de processus

进程池 signifie que nous mettons les choses que nous voulons exécuter dans le pool, Python会自行解决多进程的问题.

1. Importez le module multi-processus

Tout d'abord import multiprocessing et définissez job()

import multiprocessing as mp

def job(x):
    return x*x

2. 🎜>

Ensuite, nous définissons un

Pool

pool = mp.Pool()

Après avoir créé un pool, nous pouvons faire correspondre le pool à une certaine fonction. Nous jetons des données dans le pool, et le pool reviendra. la valeur renvoyée par la fonction. La différence entre

et le précédent Pool est que la fonction lancée au Pool par Process的 a une valeur de retour , tandis que le de Process n'a pas de valeur de retour .

Ensuite, utilisez

pour obtenir le résultat. Dans map(), vous devez mettre la fonction et la valeur qui doit être itérée. Ensuite, elle sera automatiquement attribuée au cœur du CPU et renverra le. résultat map()

res = pool.map(job, range(10))

Exécutons-le

def multicore():
    pool = mp.Pool()
    res = pool.map(job, range(10))
    print(res)
    
if __name__ == '__main__':
    multicore()

Code complété :

# -*- coding:utf-8 -*-

"""
@author: Corwien
@file: process_queue.py
@time: 18/8/26 01:12
"""

import multiprocessing as mp

def job(x):
    return x*x  # 注意这里的函数有return返回值

def multicore():
    pool = mp.Pool()
    res = pool.map(job, range(10))
    print(res)
    
if __name__ == '__main__':
    multicore()

Résultat de l'exécution :

➜  baseLearn python ./process/process_pool.py
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

3. de cœurs

Comment savoir si

appelle réellement plusieurs cœurs ? Nous pouvons augmenter le nombre d'itérations, puis ouvrir la charge CPU pour voir le fonctionnement du CPUPool

Ouvrez la charge CPU (Mac) : Moniteur d'activité>CPU>Charge CPU (un clic)

La taille par défaut du pool est le nombre de cœurs de processeur. Nous pouvons également personnaliser le nombre de cœurs requis en passant le paramètre

dans Poolprocesses

def multicore():
    pool = mp.Pool(processes=3) # 定义CPU核数量为3
    res = pool.map(job, range(10))
    print(res)

4. >

En plus de

, il existe une autre façon de renvoyer des résultats, c'est-à-dire Pool.map()apply_async()

dans

ne peut transmettre qu'une seule valeur, elle n'est qu'A core sera mis en service, mais lors du passage de la valeur, veuillez noter qu'elle est itérable, vous devez donc ajouter une virgule après la valeur transmise, et vous devez utiliser la méthode get() pour obtenir la valeur de retour apply_async()

Résultats d'exécution ;

def multicore():
    pool = mp.Pool() 
    res = pool.map(job, range(10))
    print(res)
    res = pool.apply_async(job, (2,))
    # 用get获得结果
    print(res.get())

Résumé

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]  # map()
4 # apply_async()

• L'appel par défaut est le nombre de cœurs de processeur, et le nombre de cœurs de processeur peut être personnalisé en passant le paramètre de processus

  Pool

• Entrez les paramètres d'itération et renvoyez plusieurs résultats

  map()

• Ne peut saisir qu'un seul ensemble de paramètres et renvoyer un résultat. Si vous souhaitez obtenir l'effet de map(), vous devez itérer

  apply_async()

5. Mémoire partagée mémoire partagée

Dans cette section, nous apprenons comment définir la mémoire partagée.

.

只有用共享内存才能让CPU之间有交流Valeur partagée

Nous pouvons stocker les données dans une table de mémoire partagée en utilisant

.

Value

Les paramètres

import multiprocessing as mp

value1 = mp.Value('i', 0) 
value2 = mp.Value('d', 3.14)

et

sont utilisés pour définir le type de données d représente un double de type à virgule flottante double précision, et i représente un d signé. i

Type code	C Type	Python Type	Minimum size in bytes
'b'	signed char	int	1
'B'	unsigned char	int	1
'u'	Py_UNICODE	Unicode character	2
'h'	signed short	int	2
'H'	unsigned short	int	2
'i'	signed int	int	2
'I'	unsigned int	int	2
'l'	signed long	int	4
'L'	unsigned long	int	4
'q'	signed long long	int	8
'Q'	unsigned long long	int	8
'f'	float	float	4
'd'	double	float	8

Shared Array

在Python的 mutiprocessing 中，有还有一个Array类，可以和共享内存交互，来实现在进程之间共享数据。

array = mp.Array('i', [1, 2, 3, 4])

这里的Array和numpy中的不同，它只能是一维的，不能是多维的。同样和Value 一样，需要定义数据形式，否则会报错。 我们会在后一节举例说明这两种的使用方法.

错误形式

array = mp.Array('i', [[1, 2], [3, 4]]) # 2维list

"""
TypeError: an integer is required
"""

六、进程锁Lock

不加进程锁

让我们看看没有加进程锁时会产生什么样的结果。

# -*- coding:utf-8 -*-

"""
@author: Corwien
@file: process_no_lock.py
@time: 18/8/26 09:22
"""

import multiprocessing as mp
import time

def job(v, num):
    for _ in range(5):
        time.sleep(0.5) # 暂停0.5秒，让输出效果更明显
        v.value += num  # v.value获取共享变量值
        print(v.value)

def multicore():
    v = mp.Value('i', 0)  # 定义共享变量
    p1 = mp.Process(target=job, args=(v, 1))
    p2 = mp.Process(target=job, args=(v, 4)) # 设定不同的number看如何抢夺内存
    p1.start()
    p2.start()
    p1.join()
    p2.join()

if __name__ == '__main__':
    multicore()

在上面的代码中，我们定义了一个共享变量v，两个进程都可以对它进行操作。 在job()中我们想让v每隔0.1秒输出一次累加num的结果，但是在两个进程p1和p2 中设定了不同的累加值。所以接下来让我们来看下这两个进程是否会出现冲突。

结果打印：

➜  baseLearn python ./process/process_no_lock.py
1
5
9
9
13
13
17
17
18
18
➜  baseLearn

我们可以看到，进程1和进程2在相互抢着使用共享内存v。

加进程锁

为了解决上述不同进程抢共享资源的问题，我们可以用加进程锁来解决。

首先需要定义一个进程锁

 l = mp.Lock() # 定义一个进程锁

然后将进程锁的信息传入各个进程中

p1 = mp.Process(target=job, args=(v,1,l)) # 需要将Lock传入
p2 = mp.Process(target=job, args=(v,3,l))

在job()中设置进程锁的使用，保证运行时一个进程的对锁内内容的独占

def job(v, num, l):
    l.acquire() # 锁住
    for _ in range(5):
        time.sleep(0.1) 
        v.value += num # v.value获取共享内存
        print(v.value)
    l.release() # 释放

全部代码：

# -*- coding:utf-8 -*-

"""
@author: Corwien
@file: process_lock.py
@time: 18/8/26 09:22
"""

import multiprocessing as mp
import time

def job(v, num, l):
    l.acquire() # 锁住
    for _ in range(5):
        time.sleep(0.5) # 暂停0.5秒，让输出效果更明显
        v.value += num  # v.value获取共享变量值
        print(v.value)
    l.release() # 释放

def multicore():
    l = mp.Lock() # 定义一个进程锁
    v = mp.Value('i', 0)  # 定义共享变量
    p1 = mp.Process(target=job, args=(v, 1, l)) # 需要将lock传入
    p2 = mp.Process(target=job, args=(v, 4, l)) # 设定不同的number看如何抢夺内存
    p1.start()
    p2.start()
    p1.join()
    p2.join()

if __name__ == '__main__':
    multicore()

运行一下，让我们看看是否还会出现抢占资源的情况：

结果打印：

➜  baseLearn python ./process/process_lock.py
1
2
3
4
5
9
13
17
21
25

显然，进程锁保证了进程p1的完整运行，然后才进行了进程p2的运行

相关推荐：

python 多进程通信模块

Python守护进程（多线程开发）

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!