Detaillierte Einführung in Python-Multiprozesse (mit Beispielen)

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.

Prozess

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.

Prozess erstellen

Spezielle Methoden für Linux- und Mac-Systeme

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;

Der generierte untergeordnete Prozess gibt eine 0 zurück
Der übergeordnete Prozess gibt die PID des untergeordneten Prozesses zurück;
3.Kann Window auch die Fork-Funktion verwenden?

Windows没有fork函数， Mac有fork函数(Unix -> Linux, Unix-> Mac),
封装了一个模块multiprocessing

4. Häufig verwendete Methoden:

os.fork()
os.getpid(): Ruft die PID des aktuellen Prozesses ab;
os. getppid(): übergeordnete Prozess-ID, ruft die ID-Nummer des übergeordneten Prozesses des aktuellen Prozesses ab;

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

Win-System

Unter Win-System, beim Erstellen eines Prozesses Wenn Sie den instanziierten Multiprocessing.Process verwenden, müssen Sie „if __name__=="__main__"“ hinzufügen, andernfalls wird der folgende Fehler angezeigt:

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

Daemon-Thread:

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

Einige Prozesse führen zu diesem Zeitpunkt möglicherweise erneut Endlosschleifenaufgaben aus , wir beenden den Prozess manuell

terminate()

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

Rechenintensiv -intensive Aufgaben zeichnen sich durch eine große Menge an Berechnungen und den Verbrauch von CPU-Ressourcen aus, wie z. B. die Berechnung von Pi, die hochauflösende Dekodierung von Videos usw. Alles hängt von der Rechenleistung der CPU ab. Obwohl diese Art von rechenintensiven Aufgaben auch mit Multitasking erledigt werden kann, gilt: Je mehr Aufgaben vorhanden sind, desto mehr Zeit wird für den Aufgabenwechsel aufgewendet und desto geringer ist die Effizienz der CPU bei der Ausführung von Aufgaben Auslastung der CPU, rechenintensiv. Die Anzahl der gleichzeitigen Aufgaben sollte gleich der Anzahl der CPU-Kerne sein. Da rechenintensive Aufgaben hauptsächlich CPU-Ressourcen beanspruchen, ist die Effizienz der Codeausführung von entscheidender Bedeutung. Skriptsprachen wie Python laufen sehr ineffizient und sind für rechenintensive Aufgaben völlig ungeeignet. Für rechenintensive Aufgaben ist es besser, in der Sprache C zu schreiben.

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 größte Vorteil des Multiprozessmodus ist seine hohe Stabilität, denn wenn ein Unterprozess abstürzt, hat dies keine Auswirkungen auf den Hauptprozess und andere Teilprozesse. (Wenn der Master-Prozess aufhängt, hängen natürlich alle Prozesse auf, aber der Master-Prozess ist nur für die Zuweisung von Aufgaben verantwortlich und die Wahrscheinlichkeit eines Aufhängens ist gering.) Der berühmte Apache hat zuerst den Multiprozessmodus übernommen.

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!