多进程

由于python的GIL锁，多进程才能够实现并行

多进程的PID

from multiprocessing import Process
import os
import time

class zx(Process):
    def run(self):
        time.sleep(1)
        print(f"{self.name}的PID为{os.getpid()},他的fu进程PID为{os.getppid()}")

if __name__ == '__main__':
    j1=zx()
    j1.start()
    j2=zx()
    j2.start()
    j3=zx()
    j3.start()

zx-3的PID为21236,他的fu进程PID为13116
zx-2的PID为20108,他的fu进程PID为13116
zx-1的PID为4312,他的fu进程PID为13116

他们的父进程都为主进程，因为是主进程创建的

守护进程

守护线程为方法，守护进程为一个属性

from multiprocessing import Process
import os
import time

class zx(Process):
    def run(self):
        time.sleep(1)
        print(f"{self.name}的PID为{os.getpid()},他的fu进程PID为{os.getppid()}")
        
js=[]
if __name__ == '__main__':
    j1=zx()
    js.append(j1)
    j2=zx()
    js.append(j2)
    j3=zx()
    js.append(j3)
    for i in js:
        i.daemon=True
        i.start()
    print("end")

end

进程同步

虽然进程的资源是相互独立的，但是多进程是并行，可能在同一时间去抢占系统的资源，比如屏幕资源

注意：这个锁是进程模块的锁

import multiprocessing
import time

def zx (i,lock):
    lock.acquire()
    time.sleep(0.5)
    print(i)
    lock.release()

if __name__ == '__main__':
    lock=multiprocessing.Lock()
    for i in range(10):
        i=multiprocessing.Process(target=zx,args=(i,lock))
        i.start()

进程间通讯

Queue和pipe只是实现了数据交互，并没实现数据共享，即一个进程去更改另一个进程的数据。

进程队列Queue

原理...

import multiprocessing
import time

q=multiprocessing.Queue(3)
def zx(q):
    while 1:
        time.sleep(0.5)
        q.put("来啊客官")

if __name__ == '__main__':
    j=multiprocessing.Process(target=zx,args=(q,))
    j.start()
    while 1:
        print(q.get())

管道

from multiprocessing import Process, Pipe

def f(conn):
    conn.send("爸爸你好！")
    response=conn.recv()
    print(response)
    conn.close()
    
if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    print(parent_conn.recv())   # prints "[42, None, 'hello']"
    parent_conn.send("儿子你好!")
    p.join()

爸爸你好！
儿子你好!

Managers

from multiprocessing import Process, Manager

def f(d, l,n):
    d[n] = '1'
    d['2'] = 2
    d[0.25] = None
    l.append(n)

if __name__ == '__main__':

    with Manager() as manager:
        d = manager.dict()
        l = manager.list(range(5))
        p_list = []

        for i in range(10):
            p = Process(target=f, args=(d,l,i))
            p.start()
            p_list.append(p)
        for res in p_list:
            res.join()

        print(d)
        print(l)

{6: '1', '2': 2, 0.25: None, 2: '1', 7: '1', 1: '1', 4: '1', 0: '1', 3: '1', 8: '1', 5: '1', 9: '1'}
[0, 1, 2, 3, 4, 6, 2, 7, 1, 4, 0, 3, 8, 5, 9]

进程池

• apply 同步 相当于串行

• apply_async 异步

  可以加回调函数，注意，回调函数是运行在主进程的

  可以返回子进程的run函数return

import multiprocessing
import time

def zx(i):
    time.sleep(0.5)
    print(i)
if __name__ == '__main__':
    #默认进程池的数量为你电脑的cpu数量
    pool=multiprocessing.Pool()

    for i in range(40):
        pool.apply_async(zx,args=(i,))
    pool.close()
    pool.join()
    print("搬砖结束")

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
搬砖结束