Der Inhalt dieses Artikels befasst sich mit der Frage, was SAPI in PHP ist. Wie erreichen? (Bilder und Text), es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen.
Python ist eine Sprache, die im Interpreter ausgeführt wird. Auf der Suche nach Informationen wissen wir, dass es in Python eine globale Sperre (GIL) gibt, die nicht verwendet werden kann, wenn mehrere Prozesse verwendet werden (. Thread). Vorteile von Multicore. Durch die Verwendung von Multiprocess können Sie die Vorteile von Multi-Core nutzen, um die Effizienz wirklich zu verbessern.
Wenn der Multithread-Prozess CPU-intensiv ist, verbessert Multithreading die Effizienz nicht wesentlich. Im Gegenteil, es kann zu einer Effizienzminderung aufgrund des häufigen Thread-Wechsels führen. Wenn es E/A-intensiv ist, können Multithread-Prozesse die Leerlaufzeit nutzen, während sie auf die E/A-Blockierung warten, um andere Threads auszuführen, um die Effizienz zu verbessern.
1. Das Prinzip der Erstellung eines untergeordneten Prozesses unter Linux:
1). , wenn der übergeordnete Prozess endet, endet auch der untergeordnete Prozess;
2). Wert der Fork-Funktion: Rufen Sie diese Methode einmal auf und geben Sie sie zweimal zurück;
Windows没有fork函数， Mac有fork函数(Unix -> Linux, Unix-> Mac), 封装了一个模块multiprocessing
4. Häufig verwendete Methoden:
import os
import time
print("当前进程(pid=%d)正在运行..." %(os.getpid()))
print("当前进程的父进程(pid=%d)正在运行..." %(os.getppid()))
print("正在创建子进程......")
pid = os.fork()
pid2 = os.fork()
print("第1个:", pid)
print("第2个: ", pid2)
if pid == 0:
print("这是创建的子进程， 子进程的id为%s, 父进程的id为%s"
%(os.getpid(), os.getppid()))
else:
print("当前是父进程[%s]的返回值%s" %(os.getpid(), pid))
time.sleep(100)RuntimeError:
An attempt has been made to start a new process before the current process has finished its bootstrapping phase. This probably means that you are not using fork to start your child processes and you have forgotten to use the proper idiom in the main module: if __name__ == '__main__': freeze_support() ... The "freeze_support()" line can be omitted if the program is not going to be frozen to produce an executable.
import multiprocessing
def job():
print("当前子进程的名称为%s" %(multiprocessing.current_process()))
if __name__=="__main__": #win操作系统需要加上,否则会出现异常报错RuntimeError
# 创建一个进程对象(group=None, target=None, name=None, args=(), kwargs={})
p1 = multiprocessing.Process(target=job)
p2 = multiprocessing.Process(target=job)
# 运行多进程， 执行任务
p1.start()
p2.start()
# 等待所有的子进程执行结束， 再执行主进程的内容
p1.join()
p2.join()
print("任务执行结束.......") 
Erstellen Sie mehrere Prozesse durch Überschreiben der Klasse multiprocessing.Process
from multiprocessing import Process
import multiprocessing
class JobProcess(Process):
# 重写Process的构造方法， 获取新的属性
def __init__(self,queue):
super(JobProcess, self).__init__()
self.queue = queue
# 重写run方法， 将执行的任务放在里面即可
def run(self):
print("当前进程信息%s" %(multiprocessing.current_process()))
if __name__=="__main__":
processes = []
# 启动10个子进程， 来处理需要执行的任务;
for i in range(10):
#示例化类，创建进程
p = JobProcess(queue=3)
processes.append(p)
#启动多进程，执行任务
p.start()
#等待所有的子进程结束，再执行主进程
[pro.join() for pro in processes]
print("任务执行结束")
Daemon
setDeamon: True: 主线程执行结束， 子线程不再继续执行; Flase:
Daemon:
setDeamon: True: 主进程执行结束， 子进程不再继续执行; Flase:
import multiprocessing
import time
def deamon():
#守护进程：当主程序运行结束，子进程也结束
name = multiprocessing.current_process()
print("%s开始执行" %(name))
time.sleep(3)
print("执行结束")
if __name__=="__main__":
p1 = multiprocessing.Process(target=deamon,name='hello')
p1.daemon = True
p1.start()
time.sleep(2)
print("整个程序执行结束")
Beende den Prozess
import multiprocessing
import time
def job():
name = multiprocessing.current_process()
print("%s进程开启" %(name))
time.sleep(3)
print("进程结束")
if __name__=="__main__":
p = multiprocessing.Process(target=job)
print("进程开启：",p.is_alive())
p.start()
print("进程开启：",p.is_alive())
p.terminate()
print("进程开启：",p.is_alive())
time.sleep(0.001)
print("进程开启：",p.is_alive())
print("程序执行结束") 
Rechenintensiv und I/O-intensiv
Die zweite Art von Aufgabe ist E/A-intensiv. Aufgaben, die Netzwerk- und Festplatten-E/A betreffen, sind alle E/A-intensive Aufgaben. Das Merkmal dieser Art von Aufgabe ist, dass der CPU-Verbrauch sehr gering ist, und zwar meistens Die Aufgabe besteht darin, auf den Abschluss des E/A-Vorgangs zu warten (da die E/A-Geschwindigkeit viel langsamer ist als die Geschwindigkeit von CPU und Speicher). Bei E/A-intensiven Aufgaben gilt: Je mehr Aufgaben, desto höher die CPU-Effizienz, es gibt jedoch eine Grenze. Bei den häufigsten Aufgaben handelt es sich um E/A-intensive Aufgaben, beispielsweise Webanwendungen.
Vergleich zwischen Multiprozess und Multithread
Der Nachteil des Multiprozessmodus besteht darin, dass die Kosten für die Erstellung eines Prozesses hoch sind. Unter Unix/Linux-Systemen ist das Erstellen von Prozessen unter Windows in Ordnung. Darüber hinaus ist die Anzahl der Prozesse, die das Betriebssystem gleichzeitig ausführen kann, sowohl im Speicher als auch im Speicher begrenzt. Wenn aufgrund der CPU-Begrenzung Tausende von Prozessen gleichzeitig ausgeführt werden, hat das Betriebssystem sogar Planungsprobleme.
多线程模式通常比多进程快一点， 但是也快不到哪去， 而且， 多线程模式致命的缺点就是任何一个线程挂掉都可能直接造成整个进程崩溃， 因为所有线程共享进程的内存。 在Windows上， 如果一个线程执行的代码出了问题， 你经常可以看到这样的提示：“该程序执行了非法操作， 即将关闭”， 其实往往是某个线程出了问题， 但是操作系统会强制结束整个进程。
这里通过一个计算密集型任务，来测试多进程和多线程的执行效率。
import multiprocessing
import threading
from mytimeit import timeit
class JobProcess(multiprocessing.Process):
def __init__(self,li):
super(JobProcess, self).__init__()
self.li = li
def run(self):
for i in self.li:
sum(i)
class JobThread(threading.Thread):
def __init__(self,li):
super(JobThread, self).__init__()
self.li = li
def run(self):
for i in self.li:
sum(i)
@timeit
def many_processs():
li = [[24892,23892348,239293,233],[2382394,49230,2321234],[48294,28420,29489]]*10
processes = []
for i in li :
p = JobProcess(li)
processes.append(p)
p.start()
[pro.join() for pro in processes]
print("多进程执行任务结束，✌")
@timeit
def many_thread():
#创建进程和销毁进程是时间的，如果li长度不够，会造成多线程快过多进程
li = [[24892,23892348,239293,233],[2382394,49230,2321234],[48294,28420,29489]]*1000
threads = []
for i in li :
t = JobThread(li)
threads.append(t)
t.start()
[thread.join() for thread in threads]
print("多线程执行任务结束，✌")
if __name__ =="__main__":
many_processs()
many_thread()
演示了生产者和消费者的场景。生产者生产货物，然后把货物放到一个队列之类的数据结构中，生产货物所要花费的时间无法预先确定。消费者消耗生产者生产的货物的时间也是不确定的。
通过队列来实现进程间的通信
import multiprocessing
import threading
from multiprocessing import Queue
class Producer(multiprocessing.Process):
def __init__(self,queue):
super(Producer, self).__init__()
self.queue = queue
def run(self):
for i in range(13):
#往队列添加内容
self.queue.put(i)
print("生产者传递的消息为%s" %(i))
return self.queue
class Consumer(multiprocessing.Process):
def __init__(self,queue):
super(Consumer, self).__init__()
self.queue = queue
def run(self):
#获取队列内容
#get会自动判断队列是否为空,如果是空， 跳出循环， 不会再去从队列获取数据;
while True:
print("进程获取消息为：%s" %(self.queue.get()))
if __name__=="__main__":
queue = Queue(maxsize=100)
p = Producer(queue)
p.start()
c = Consumer(queue)
c.start()
p.join()
c.join(2)
c.terminate() #终止进程
print("进程间通信结束，( •̀ ω •́ )y")
Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in Python-Multiprozesse (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
