Detaillierte Einführung in Multiprozesse in Python (Codebeispiel)

Der Inhalt dieses Artikels ist eine detaillierte Einführung (Codebeispiel) über Multiprozesse in Python. Ich hoffe, dass er für Sie hilfreich ist.

In diesem Abschnitt geht es um das Erlernen des Multiprozesses von Python.

1. Vergleich zwischen Multiprozess und Multithreading

Multiprozess Multiprocessing Sie werden beide für 并行 Operationen in Python verwendet Warum gibt es Threading? Der Grund dafür ist ganz einfach: Es dient dazu, einige Nachteile des Threadings auszugleichen, wie im Threading-Tutorial erwähnt.GIL

Die Verwendung von Multiprocessing ist Auch sehr einfach. Freunde, die ein gewisses Verständnis haben, können es hier genießen, denn Python macht die Verwendung von Multiprocessing und Threading für uns einfacher Das Multi-Core-System Ihres Computers!

2. Prozess hinzufügen Prozess

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()

Wie aus dem obigen Verwendungsvergleichscode ersichtlich ist, werden Threads und Prozesse auf ähnliche Weise verwendet.

Bei Verwendung von

müssen Sie eine Anweisung hinzufügen, die die Hauptfunktion definiert

if __name__=='__main__':

Vollständiger Anwendungscode:

# -*- 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()

Die laufende Umgebung muss sich im Terminal befinden Umgebung Als nächstes haben andere Bearbeitungstools nach der Ausführung möglicherweise kein gedrucktes Ergebnis. Das gedruckte Ergebnis nach der Ausführung im Terminal lautet:

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

3. Gespeicherte Prozessausgabewarteschlange

Die Funktion der Warteschlange lautet Laden Sie die Operationsergebnisse jedes Kerns oder Threads in der Warteschlange herunter, warten Sie, bis die Ausführung jedes Threads oder Kerns abgeschlossen ist, nehmen Sie dann die Ergebnisse aus der Warteschlange und fahren Sie mit dem Laden der Operation fort. Der Grund ist sehr einfach. Von mehreren Threads aufgerufene Funktionen können keinen Rückgabewert haben, daher wird die Warteschlange zum Speichern der Ergebnisse mehrerer Thread-Operationen verwendet

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

Ausgabeergebnis ausgeben:

➜ python ./process/process_queue.py
249833583000 249833583000

4. Prozesspool

bedeutet, dass wir die Dinge, die wir ausführen möchten, in den Pool legen, 进程池. Python会自行解决多进程的问题

1. Importieren Sie das Multiprozessmodul

Zuerst

und definieren Sie import multiprocessingjob()

import multiprocessing as mp

def job(x):
    return x*x

2

Dann definieren wir ein

pool = mp.Pool()

PoolNachdem wir einen Pool haben, können wir dafür sorgen, dass der Pool einer bestimmten Funktion entspricht. Wir werfen Daten in den Pool und der Pool gibt den von zurückgegebenen Wert zurück die Funktion. Der Unterschied zwischen und dem vorherigen

besteht darin, dass die von Pool in den Pool geworfene Funktion einen Rückgabewert Process的 hat, während das von keinen Rückgabewert Process hat . Als nächstes verwenden Sie

, um das Ergebnis zu erhalten. In

müssen Sie die Funktion und den Wert eingeben, der iteriert werden muss. Anschließend wird er automatisch dem CPU-Kern zugewiesen und das Ergebnis wird zurückgegeben. map()

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

map() Lassen Sie uns

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

ausführen, um den Code zu vervollständigen:

# -*- 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()

Benutzerdefinierte Anzahl von Kernen

Woher wissen wir, ob

tatsächlich mehrere Kerne aufgerufen werden? Wir können die Anzahl der Iterationen erhöhen und dann die CPU-Auslastung öffnen, um den CPU-Betrieb zu sehen

CPU-Auslastung öffnen (Mac): Aktivitätsmonitor>CPU>CPU-Auslastung (ein Klick)

Pool Die Standardgröße des Pools ist die Anzahl der Kerne der CPU. Wir können die erforderliche Anzahl von Kernen auch anpassen, indem wir den Parameter

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

4 übergeben >

PoolZusätzlich zu processes gibt es eine andere Möglichkeit, Ergebnisse zurückzugeben, nämlich

.

In Pool kann map() nur einen Wert übergeben , es wird nur ein Kern für die Eingabe eingegeben, aber wenn Sie den Wert übergeben, beachten Sie bitte, dass er iterierbar ist. Sie müssen also nach dem eingehenden Wert ein Komma hinzufügen und die Methode get () verwenden, um den Wert zu erhalten Rückgabewert apply_async()

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

laufendes Ergebnis ;apply_async()

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

Zusammenfassung

Der Standardaufruf ist die Anzahl der übergebenen CPU-Kerne Der Prozessparameter kann die Anzahl der CPU-Kerne anpassen

• Pool Geben Sie Iterationsparameter ein und geben Sie mehrere Ergebnisse zurück

• map()Das ist möglich Geben Sie nur einen Parametersatz ein und geben Sie ein Ergebnis zurück. Wenn Sie map() erhalten möchten, muss der Effekt durch

• 5. Shared Memory Shared Memory apply_async() In diesem Abschnitt lernen wir, wie man Shared Memory definiert.

  .

Gemeinsamer Wert

Mit

können wir die Daten in einer Shared-Memory-Tabelle speichern. 只有用共享内存才能让CPU之间有交流

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

Die Parameter

und

werden zum Festlegen des Datentyps verwendet.

stellt einen Gleitkommatyp mit doppelter Genauigkeit dar, und Value stellt einen vorzeichenbehafteten

dar.

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守护进程（多线程开发）

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in Multiprozesse in Python (Codebeispiel). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!