Erfahren Sie mehr über Python-Prozesspools und Prozesssperren

Dieser Artikel vermittelt Ihnen relevantes Wissen über Python. Er stellt hauptsächlich Probleme im Zusammenhang mit Prozesspools und Prozesssperren vor, einschließlich Prozesspool-Erstellungsmodulen, Prozesspoolfunktionen usw. Wir hoffen, dass es allen hilft.

Empfohlenes Lernen: Python-Video-Tutorial

Prozesspool

Was ist ein Prozesspool? Wir haben im vorherigen Kapitel über Prozesse erwähnt, dass Ressourcen verbraucht werden, wenn zu viele Prozesse erstellt werden. Zu groß. Um diese Situation zu vermeiden, müssen wir die Anzahl der Prozesse festlegen und benötigen zu diesem Zeitpunkt die Hilfe des Prozesspools.

Wir können uns den Prozesspool als einen Pool vorstellen, in dem im Voraus eine bestimmte Anzahl von Prozessen erstellt wird. Siehe das Bild unten:

---

Dieses rote rechteckige Array stellt beispielsweise einen Prozesspool dar, und dieser Pool enthält 6 Prozesse. Diese 6 Prozesse werden zusammen mit dem Prozesspool erstellt. Darüber hinaus haben wir beim Erlernen des objektorientierten Lebenszyklus einmal gesagt, dass jedes instanziierte Objekt nach der Verwendung vom Speichermanager recycelt wird.

---

Unser Prozess wird beim Erstellen und Herunterfahren auch vom Speichermanager recycelt. Dies gilt für jeden Prozess, der nach dem Herunterfahren erstellt wird. Die Prozesse im Prozesspool werden nach ihrer Erstellung nicht geschlossen und können jederzeit wiederverwendet werden, wodurch der Ressourcenverbrauch beim Erstellen und Schließen sowie wiederholte Erstellungs- und Schließvorgänge vermieden werden, was die Effizienz verbessert.

Wenn wir mit der Ausführung des Programms fertig sind und der Prozesspool geschlossen ist, wird natürlich auch der Prozess geschlossen.

Wenn wir eine Aufgabe haben, die ausgeführt werden muss, ermitteln wir, ob sich im aktuellen Prozesspool Leerlaufprozesse befinden (die sogenannten Leerlaufprozesse sind tatsächlich Prozesse im Prozesspool, die keine Aufgaben ausführen). Wenn ein Prozess inaktiv ist, findet die Aufgabe den Prozess, der die Aufgabe ausführt. Wenn sich alle Prozesse im aktuellen Prozesspool in einem nicht inaktiven Zustand befinden, wechselt die Aufgabe in den Wartezustand. Sie tritt nicht in den Prozesspool ein oder verlässt ihn, bis ein Prozess im Prozesspool inaktiv ist, um die Aufgabe auszuführen.

Dies ist die Rolle des Prozesspools.

Erstellungsmodul des Prozesspools – Multiprocessing

Prozesspoolfunktion erstellen – Pool

FunktionsnameP ool

Einführung	Parameter	Rückgabewert
Prozesspool Erstellen Sie ein	Processcount	Prozesspoolobjekt

Pool功能介绍：通过调用 "multiprocessing" 模块的 "Pool" 函数来帮助我们创建 "进程池对象" ，它有一个参数 "Processcount" （一个整数），代表我们这个进程池中创建几个进程。

Gemeinsame Methoden des Prozesspools

Nachdem wir ein Prozesspoolobjekt erstellt haben, müssen wir einen Blick auf die gängigen Methoden werfen Methode (Funktion).

Funktionsnameapply_asyncschließen

Einführung

Parameter

Rückgabewert

Aufgabe zum Prozesspool hinzugefügt (asynchron)

func, args

Keine

Schließen Sie den Prozesspool

• apply_async-Funktion: Ihre Funktion besteht darin, Aufgaben zum Prozesspool hinzuzufügen, und sie wird asynchron implementiert. Asynchron Wir haben dieses Wissen noch nicht gelernt, daher müssen wir uns noch keine Gedanken darüber machen, was es bedeutet. Es hat zwei Parameter: func und agrs, func ist eine Funktion, die dem Prozesspool hinzugefügt wird; args ist ein Tupel, das die Parameter einer Funktion darstellt, was dasselbe ist, als würden wir einen Prozess erstellen und verwenden . Völlig stimmig.
异步 这个知识我们还没有学习，先不用关心它到底是什么意思。它有两个参数：func 与 agrs , func 是加入进程池中工作的函数；args 是一个元组，代表着签一个函数的参数，这和我们创建并使用一个进程是完全一致的。
• close 函数：当我们使用完进程池之后，通过调用 close 函数可以关闭进程池。它没有任何的参数，也没有任何的返回值。
• join 函数：它和我们上一章节学习的 创建进程的 join 函数中方法是一致的。只有进程池中的任务全部执行完毕之后，才会执行后续的任务。不过一般它会伴随着进程池的关闭（close 函数）才会使用。

apply_async 函数演示案例

接下里我们在 Pycharm 中创建一个脚本，练习一下关于进程池的使用方法。

• 定义一个函数，打印输出该函数 每次被执行的次数 与 该次数的进程号
• 定义进程池的数量，每一次的执行进程数量最多为该进程池设定的进程数

示例代码如下：

# coding:utf-8import osimport timeimport multiprocessingdef work(count):    
# 定义一个 work 函数，打印输出 每次执行的次数 与 该次数的进程号
    print('\'work\' 函数 第 {} 次执行，进程号为 {}'.format(count, os.getpid()))
    time.sleep(3)
    # print('********')if __name__ == '__main__':
    pool = multiprocessing.Pool(3)      
    # 定义进程池的进程数量，同一时间每次执行最多3个进程
    for i in range(21):
        pool.apply_async(func=work, args=(i,))      
        # 传入的参数是元组，因为我们只有一个 i 参数，所以我们要写成 args=(i,)

    time.sleep(15)      
    # 这里的休眠时间是必须要加上的，否则我们的进程池还未运行，主进程就已经运行结束，对应的进程池也会关闭。

运行结果如下：

---

从上图中我们可以看到每一次都是一次性运行三个进程，每一个进程的进程号是不一样的，但仔细看会发现存在相同的进程号，这说明进程池的进程号在被重复利用。这证明我们上文介绍的内容，进程池中的进程不会被关闭，可以反复使用。

而且我们还可以看到每隔3秒都会执行3个进程，原因是我们的进程池中只有3个进程；虽然我们的 for 循环 中有 21 个任务，work 函数会被执行21次，但是由于我们的进程池中只有3个进程。所以当执行了3个任务之后（休眠3秒），后面的任务等待进程池中的进程处于空闲状态之后才会继续执行。

同样的，进程号在顺序上回出现一定的区别，原因是因为我们使用的是一种 异步 的方法（异步即非同步）。这就导致 work 函数 一起执行的三个任务会被打乱顺序，这也是为什么我们的进程号出现顺序不一致的原因。（更多的异步知识我们会在异步的章节进行详细介绍）

进程池的原理： 上述脚本的案例证实了我们进程池关于进程的限制，只有当我们进程池中的进程处于空闲状态的时候才会将进程池外等待的任务扔到进程池中工作。

---

 close 函数与 join 函数 演示

在上文的脚本中, 我们使用 time.sleep(15) 帮助我们将主进程阻塞15秒钟再次退出，所以给了我们进程池足够的时间完成我们的 work() 函数的循环任务。

如果没有 time.sleep(15) 这句话又怎么办呢，其实这里就可以使用进程的 join 函数了。不过上文我们也提到过，进程的 join() 函数一般都会伴随进程池的关闭（close 函数）来使用。接下来，我们就将上文脚本中的 time.sleep(15) 替换成 join() 函数试一下。

示例代码如下：

# coding:utf-8import osimport timeimport multiprocessingdef work(count):    
# 定义一个 work 函数，打印输出 每次执行的次数 与 该次数的进程号
    print('\'work\' 函数 第 {} 次执行，进程号为 {}'.format(count, os.getpid()))
    time.sleep(3)
    # print('********')if __name__ == '__main__':
    pool = multiprocessing.Pool(3)      # 定义进程池的进程数量，同一时间每次执行最多3个进程
    for i in range(21):
        pool.apply_async(func=work, args=(i,))      
        # 传入的参数是元组，因为我们只有一个 i 参数，所以我们要写成 args=(i,)

    # time.sleep(15) 
    pool.close()
    pool.join()

运行结果如下：

---

从上面的动图我们可以看出，work() 函数的任务与进程池中的进程与使用 time.sleep(15)的运行结果一致。

PS：如果我们的主进程会一直执行，不会退出。那么我们并不需要添加 close() 与 join() 函数 ，可以让进程池一直启动着，直到有任务进来就会执行。

在后面学习 WEB 开发之后，不退出主进程进行工作是家常便饭。还有一些需要长期执行的任务也不会关闭，但要是只有一次性执行的脚本，就需要添加 close() 与 join() 函数 来保证进程池的任务全部完成之后主进程再退出。当然，如果主进程关闭了，就不会再接受新的任务了，也就代表了进程池的终结。

---

接下来再看一个例子，在 work 函数 中加入一个 return。

这里大家可能会有一个疑问，在上一章节针对进程的知识点明明说的是 进程无法获取返回值，那么这里的 work() 函数增加的 returnSchließfunktion: Nachdem wir die Verwendung des Prozesspools beendet haben, können wir den Prozesspool schließen, indem wir die Schließfunktion aufrufen. Es hat keine Parameter und keinen Rückgabewert.

Join-Funktion: Sie stimmt mit der Join-Funktion überein, die wir im vorherigen Kapitel zum Erstellen eines Prozesses gelernt haben. Erst nachdem alle Aufgaben im Prozesspool ausgeführt wurden, werden nachfolgende Aufgaben ausgeführt. Sie wird jedoch im Allgemeinen verwendet, wenn der Prozesspool geschlossen wird (Schließfunktion).

Demonstrationsfall für die Funktion „Apply_async“

Als nächstes erstellen wir ein Skript in Pycharm, um die Verwendung des Prozesspools zu üben. 🎜🎜🎜🎜Definieren Sie eine Funktion und geben Sie aus, wie oft die Funktion jedes Mal ausgeführt wird, sowie die Prozessnummer dieser Anzahl.🎜Definieren Sie die Anzahl der Prozesspools, die jeweils ausgeführt werden die Anzahl der für den Prozesspool festgelegten Prozesse. Anzahl

Der Beispielcode lautet wie folgt: 🎜

# coding:utf-8import osimport timeimport multiprocessingdef work(count):    # 定义一个 work 函数，打印输出 每次执行的次数 与 该次数的进程号
    print('\'work\' 函数 第 {} 次执行，进程号为 {}'.format(count, os.getpid()))
    time.sleep(3)
    return '\'work\' 函数 result 返回值为：{}, 进程ID为：{}'.format(count, os.getpid())if __name__ == '__main__':
    pool = multiprocessing.Pool(3)      # 定义进程池的进程数量，同一时间每次执行最多3个进程
    results = []
    for i in range(21):
        result = pool.apply_async(func=work, args=(i,))      # 传入的参数是元组，因为我们只有一个 i 参数，所以我们要写成 args=(i,)
        results.append(result)

    for result in results:
        print(result.get())     # 可以通过这个方式返回 apply_async 的返回值，
                                # 通过这种方式也不再需要 使用 close()、join() 函数就可以正常执行。

    # time.sleep(15)      # 这里的休眠时间是必须要加上的，否则我们的进程池还未运行，主进程就已经运行结束，对应的进程池也会关闭。
    # pool.close()
    # pool.join()

Das laufende Ergebnis lautet wie folgt: 🎜

---

🎜

Auf dem Bild oben können wir sehen, dass jedes Mal, wenn drei Prozesse gleichzeitig ausgeführt werden, die Prozessnummer jedes Prozesses unterschiedlich ist. Wenn Sie jedoch genau hinsehen, werden Sie feststellen, dass dieselbe Prozessnummer vorhanden ist zeigt an, dass die Prozessnummer des Prozesspools wiederverwendet wird. Dies beweist, was wir oben eingeführt haben: Die Prozesse im Prozesspool werden nicht geschlossen und können wiederholt verwendet werden. 🎜

Und wir können auch sehen, dass alle 3 Sekunden 3 Prozesse ausgeführt werden, da sich in unserem Prozesspool nur 3 Prozesse befinden, obwohl sich in unserer for-Schleife 21 Aufgaben befinden 21 Mal ausgeführt werden, da es aber nur 3 Prozesse in unserem Prozesspool gibt. Nach der Ausführung von 3 Aufgaben (3 Sekunden im Ruhezustand) warten die nachfolgenden Aufgaben, bis der Prozess im Prozesspool inaktiv ist, bevor sie mit der Ausführung fortfahren. 🎜

Ebenso gibt es einen gewissen Unterschied in der Reihenfolge der Prozessnummern. Der Grund dafür ist, dass wir eine asynchrone Methode verwenden (asynchron bedeutet asynchron). Dies führt dazu, dass die drei von der Arbeitsfunktion gemeinsam ausgeführten Aufgaben nicht in der richtigen Reihenfolge sind, weshalb unsere Prozessnummern in inkonsistenter Reihenfolge angezeigt werden. (Wir werden im Kapitel über asynchrone Prozesse ausführlicher vorstellen) 🎜

Das Prinzip des Prozesspools: Der obige Skriptfall bestätigt die Einschränkungen unseres Prozesspools für Prozesse Die Prozesse in unserem Prozesspool sind inaktiv, Aufgaben, die außerhalb des Prozesspools warten, werden zur Arbeit in den Prozesspool geworfen. 🎜

---

Funktion schließen und Funktionsdemonstration beitreten

Im obigen Skript verwenden wir time.sleep(15) Code> hilft uns, den Hauptprozess für 15 Sekunden zu blockieren, bevor er wieder beendet wird, und gibt so unserem Prozesspool genügend Zeit, um die Schleifenaufgabe unserer work()-Funktion abzuschließen. 🎜<p>Was ist, wenn es keinen <code>time.sleep(15)-Satz gibt? Tatsächlich kann hier die join-Funktion des Prozesses verwendet werden. Allerdings haben wir oben auch erwähnt, dass die Funktion join() eines Prozesses im Allgemeinen verwendet wird, wenn der Prozesspool geschlossen wird (Funktion schließen). Versuchen wir als Nächstes, time.sleep(15) durch die Funktion join() im obigen Skript zu ersetzen. 🎜

Der Beispielcode lautet wie folgt: 🎜

# coding:utf-8import osimport timeimport multiprocessingdef work(count, lock):    # 定义一个 work 函数，打印输出 每次执行的次数 与 该次数的进程号,增加线程锁。
    lock.acquire()        # 上锁
    print('\'work\' 函数 第 {} 次执行，进程号为 {}'.format(count, os.getpid()))
    time.sleep(3)
    lock.release()        # 解锁
    return '\'work\' 函数 result 返回值为：{}, 进程ID为：{}'.format(count, os.getpid())if __name__ == '__main__':
    pool = multiprocessing.Pool(3)      # 定义进程池的进程数量，同一时间每次执行最多3个进程
    manager = multiprocessing.Manager()
    lock = manager.Lock()
    results = []
    for i in range(21):
        result = pool.apply_async(func=work, args=(i, lock))      # 传入的参数是元组，因为我们只有一个 i 参数，所以我们要写成 args=(i,)
        # results.append(result)


    # time.sleep(15)      # 这里的休眠时间是必须要加上的，否则我们的进程池还未运行，主进程就已经运行结束，对应的进程池也会关闭。
    pool.close()
    pool.join()

Das laufende Ergebnis lautet wie folgt: 🎜

---

🎜

Aus der obigen Animation können wir sehen, dass die Aufgaben des funktionieren ()-Funktion Das Ergebnis der Ausführung des Prozesses im Prozesspool stimmt mit der Verwendung von time.sleep(15) überein. 🎜

PS: Wenn unser Hauptprozess immer ausgeführt wird, wird er nicht beendet. Dann müssen wir die Funktionen close() und join() nicht hinzufügen, sondern können den Prozesspool gestartet lassen, bis eine Aufgabe eintrifft und ausgeführt wird. 🎜

Nachdem man später die WEB-Entwicklung erlernt hat, ist es üblich, zu arbeiten, ohne den Hauptprozess zu verlassen. Es gibt auch einige Aufgaben, die über einen längeren Zeitraum ausgeführt werden müssen und nicht geschlossen werden. Wenn jedoch nur einmal ausgeführte Skripte vorhanden sind, müssen Sie die Funktionen close() und join() hinzufügen. Code> um sicherzustellen, dass der Hauptprozesspool nicht geschlossen wird, nachdem alle Aufgaben im Prozesspool abgeschlossen sind. Wenn der Hauptprozess geschlossen wird, nimmt er natürlich keine neuen Aufgaben mehr an, was das Ende des Prozesspools bedeutet. 🎜<hr>🎜<p>Sehen wir uns ein weiteres Beispiel an und fügen der <code>work-Funktion eine Rückkehr hinzu. 🎜

Möglicherweise haben Sie hier eine Frage. Im vorherigen Kapitel wurde im Wissenspunkt zum Prozess klar angegeben, dass der Prozess den Rückgabewert nicht erhalten kann, daher ist hier work()-Funktion hinzugefügte <code>return? 🎜

其实不然，在我们的使用进程池的 apply_async 方法时，是通过异步的方式实现的，而异步是可以获取返回值的。针对上述脚本，我们在 for循环中针对每一个异步 apply_async 添加一个变量名，从而获取返回值。

示例代码如下：

# coding:utf-8import osimport timeimport multiprocessingdef work(count):    # 定义一个 work 函数，打印输出 每次执行的次数 与 该次数的进程号
    print('\'work\' 函数 第 {} 次执行，进程号为 {}'.format(count, os.getpid()))
    time.sleep(3)
    return '\'work\' 函数 result 返回值为：{}, 进程ID为：{}'.format(count, os.getpid())if __name__ == '__main__':
    pool = multiprocessing.Pool(3)      # 定义进程池的进程数量，同一时间每次执行最多3个进程
    results = []
    for i in range(21):
        result = pool.apply_async(func=work, args=(i,))      # 传入的参数是元组，因为我们只有一个 i 参数，所以我们要写成 args=(i,)
        results.append(result)

    for result in results:
        print(result.get())     # 可以通过这个方式返回 apply_async 的返回值，
                                # 通过这种方式也不再需要 使用 close()、join() 函数就可以正常执行。

    # time.sleep(15)      # 这里的休眠时间是必须要加上的，否则我们的进程池还未运行，主进程就已经运行结束，对应的进程池也会关闭。
    # pool.close()
    # pool.join()

运行结果如下：

---

从运行结果可以看出，首先 work() 函数被线程池的线程执行了一遍，当第一组任务执行完毕紧接着执行第二次线程池任务的时候，打印输出了 apply_async 的返回值，证明返回值被成功的返回了。然后继续下一组的任务…

这些都是主要依赖于 异步 ，关于 异步 的更多知识会在 异步 的章节进行详细的介绍。

---

进程锁

 进程锁的概念

锁：大家都知道，我们可以给一个大门上锁。

结合这个场景来举一个例子：比如现在有多个进程同时冲向一个 "大门" ，当前门内是没有 "人"的(其实就是进程)，锁也没有锁上。当有一个进程进去之后并且把 “门” 锁上了，这时候门外的那些进程是进不来的。在门内的 “人” ，可以在 “门” 内做任何事情且不会被干扰。当它出来之后，会解开门锁。这时候又有一个 “人” 进去了门内，并且重复这样的操作，这就是 进程锁。它可以让锁后面的工作只能被一个任务来处理，只有它解锁之后下一个任务才会进入，这就是 “锁” 的概念。

而 进程锁 就是仅针对于 进程 有效的锁，当进程的任务开始之后，就会被上一把 “锁”；与之对应的是 线程锁 ，它们的原理几乎是一样的。

进程锁的加锁与解锁

进程锁的使用方法：

通过 multiprocessing 导入 Manager 类

from multiprocessing import Manager

然后实例化 Manager

manager = Manager()

再然后通过实例化后的 manager 调用 它的 Lock() 函数

lock = manager.Lock()

接下来，就需要操作这个 lock 对象的函数

函数名	介绍	参数	返回值
acquire	上锁	无	无
release	解锁（开锁）	无	无

代码示例如下：

# coding:utf-8import osimport timeimport multiprocessingdef work(count, lock):    # 定义一个 work 函数，打印输出 每次执行的次数 与 该次数的进程号,增加线程锁。
    lock.acquire()        # 上锁
    print('\'work\' 函数 第 {} 次执行，进程号为 {}'.format(count, os.getpid()))
    time.sleep(3)
    lock.release()        # 解锁
    return '\'work\' 函数 result 返回值为：{}, 进程ID为：{}'.format(count, os.getpid())if __name__ == '__main__':
    pool = multiprocessing.Pool(3)      # 定义进程池的进程数量，同一时间每次执行最多3个进程
    manager = multiprocessing.Manager()
    lock = manager.Lock()
    results = []
    for i in range(21):
        result = pool.apply_async(func=work, args=(i, lock))      # 传入的参数是元组，因为我们只有一个 i 参数，所以我们要写成 args=(i,)
        # results.append(result)


    # time.sleep(15)      # 这里的休眠时间是必须要加上的，否则我们的进程池还未运行，主进程就已经运行结束，对应的进程池也会关闭。
    pool.close()
    pool.join()

执行结果如下：

---

从上图中，可以看到每一次只有一个任务会被执行。由于每一个进程会被阻塞 3秒钟，所以我们的进程执行的非常慢。这是因为每一个进程进入到 work() 函数中，都会执行 上锁、阻塞3秒、解锁 的过程，这样就完成了一个进程的工作。下一个进程任务开始，重复这个过程… 这就是 进程锁的概念。

---

其实进程锁还有很多种方法，在 multiprocessing 中有一个直接使用的锁，就是 ``from multiprocessing import Lock。这个Lock的锁使用和我们刚刚介绍的Manager` 的锁的使用有所区别。（这里不做详细介绍，感兴趣的话可以自行拓展一下。）

锁 的使用可以让我们对某个任务 在同一时间只能对一个进程进行开发，但是 锁也不可以乱用 。因为如果某些原因造成 锁没有正常解开 ，就会造成死锁的现象，这样就无法再进行操作了。

因为 锁如果解不开 ，后面的任务也就没有办法继续执行任务，所以使用锁一定要谨慎。

推荐学习：python视频教程

Das obige ist der detaillierte Inhalt vonErfahren Sie mehr über Python-Prozesspools und Prozesssperren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!