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
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:
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| Einführung | Parameter | Rückgabewert | |
|---|---|---|---|
| Prozesspool Erstellen Sie ein | Processcount | Prozesspoolobjekt |
Pool功能介绍：通过调用 "multiprocessing" 模块的 "Pool" 函数来帮助我们创建 "进程池对象" ，它有一个参数 "Processcount" （一个整数），代表我们这个进程池中创建几个进程。
| Einführung | Parameter | Rückgabewert | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Aufgabe zum Prozesspool hinzugefügt (asynchron) | func, args | Keine | ||||||||||
Schließen Sie den Prozesspool
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)
# 这里的休眠时间是必须要加上的，否则我们的进程池还未运行，主进程就已经运行结束，对应的进程池也会关闭。Nach dem Login kopieren 运行结果如下：
从上图中我们可以看到每一次都是一次性运行三个进程，每一个进程的进程号是不一样的，但仔细看会发现存在相同的进程号，这说明进程池的进程号在被重复利用。这证明我们上文介绍的内容，进程池中的进程不会被关闭，可以反复使用。 而且我们还可以看到每隔3秒都会执行3个进程，原因是我们的进程池中只有3个进程；虽然我们的 同样的，进程号在顺序上回出现一定的区别，原因是因为我们使用的是一种
close 函数与 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()Nach dem Login kopieren 运行结果如下：
从上面的动图我们可以看出， PS：如果我们的主进程会一直执行，不会退出。那么我们并不需要添加 在后面学习 WEB 开发之后，不退出主进程进行工作是家常便饭。还有一些需要长期执行的任务也不会关闭，但要是只有一次性执行的脚本，就需要添加
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()Nach dem Login kopieren Nach dem Login kopieren 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 Ebenso gibt es einen gewissen Unterschied in der Reihenfolge der Prozessnummern. Der Grund dafür ist, dass wir eine
Funktion schließen und Funktionsdemonstration beitretenIm obigen Skript verwenden wir 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()Nach dem Login kopieren Nach dem Login kopieren Das laufende Ergebnis lautet wie folgt: 🎜
Aus der obigen Animation können wir sehen, dass die Aufgaben des PS: Wenn unser Hauptprozess immer ausgeführt wird, wird er nicht beendet. Dann müssen wir die Funktionen 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 Möglicherweise haben Sie hier eine Frage. Im vorherigen Kapitel wurde im Wissenspunkt zum Prozess klar angegeben, dass 其实不然，在我们的使用进程池的 示例代码如下： # 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()Nach dem Login kopieren Nach dem Login kopieren 运行结果如下：
从运行结果可以看出，首先 这些都是主要依赖于 进程锁进程锁的概念锁：大家都知道，我们可以给一个大门上锁。 结合这个场景来举一个例子：比如现在有多个进程同时冲向一个 而 进程锁的加锁与解锁进程锁的使用方法：
代码示例如下： # 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()Nach dem Login kopieren Nach dem Login kopieren 执行结果如下：
从上图中，可以看到每一次只有一个任务会被执行。由于每一个进程会被阻塞 3秒钟，所以我们的进程执行的非常慢。这是因为每一个进程进入到 work() 函数中，都会执行 其实进程锁还有很多种方法，在
因为 推荐学习：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!
🎜
