2023年8月2日发(作者：)

python并发、异步—多进程python并发-多进程 多进程能实现真正意义上的并发(并⾏)，能利⽤多核优势，适⽤计算密集型的程序1 Process类开启⼦进程—函数import timefrom multiprocessing import Processdef p_func(name): (3) print(name, ": ok")if __name__ == '__main__':

p = Process(target=p_func, args=("lynn",)) () print("主进程")注意： Process中的关键字参数，target的值是⽅法名字，args是元组 start()⽅法，开启⼦进程 ⼦进程是异步的开启⼦进程—类import timefrom multiprocessing import Processclass PClass(Process): def __init__(self, name): super().__init__() = name def run(self): (2) print("name: ", )if __name__ == '__main__': p = PClass("lynn") () print("主")注意： 继承Process，重写__init__⽅法，必须有super().__init__() 必须有run⽅法，start()⽅法会⾃动调⽤run⽅法 ⼦进程是异步的 进程之间的内存是完全隔离的Process对象的join⽅法import timefrom multiprocessing import Processclass PClass(Process): def __init__(self, name): super().__init__() = name def run(self): (1) print("name:", )if __name__ == '__main__': p = PClass("lynn") () print("主开") () print("主")注意： join()⽅法会阻塞，上边开启的所有的⼦进程全部运⾏完成，才继续往下运⾏，并不是所有的进程是串⾏，只是在这会阻塞Process对象的其他⽅法或属性is__alive() # 查看进程是否存活，True/ # 进程的pid2 特殊的进程守护进程 守护进程会在主进程运⾏结束时，⽴马停⽌运⾏ 守护进程内⽆法开启⼦进程，会报错from multiprocessing import Processimport timeclass PClass(Process): def __init__(self, name): super().__init__() = name def run(self): (1) print("name:", )if __name__ == '__main__': p = PClass("lynn") p1 = PClass("fancy") = True # 设置p为守护进程 () () print("主") # 打印时，p进程停⽌运⾏注意：

= True必须在()之前其他僵⼫进程： ⼦进程在运⾏完后，不会把所有的资源回收，会告诉⽗进程⾃⼰运⾏完毕，等待⽗进程回收，那么这个过程中没有完全死的进程，就是僵⼫进程孤⼉进程： ⽗进程死了，但是还有⼦进程活着，这些⼦进程称为孤⼉进程3 进程的⾼级应⽤进程同步—锁进程之间数据虽然隔离，但是可能会操作同⼀个数据库，同⼀个⽂件等外部资源，可能会造成数据的错乱，所以多进程在处理外部资源时要加锁处理数据错乱from multiprocessing import Processimport timeclass PClass(Process): def __init__(self, name): super().__init__() = name def run(self): with open("", "wt", encoding="utf-8")as f: () (0.1) with open("", "rt", encoding="utf-8")as f: print("name:", ,())if __name__ == '__main__': lock = Lock() lynn_p = PClass("lynn") fancy_p = PClass("fancy") lynn_() fancy_() print("完")加锁from multiprocessing import Processfrom multiprocessing import Lockimport timeclass PClass(Process): def __init__(self, name, lock): super().__init__() = name = lock def run(self): e() # 加锁 相当于with : # with : with open("", "wt", encoding="utf-8")as f: () (0.1) with open("", "rt", encoding="utf-8")as f: print("name:", , ()) e() # 开锁if __name__ == '__main__': lock = Lock() lynn_p = PClass("lynn", lock) fancy_p = PClass("fancy", lock) lynn_() fancy_() print("完")注意： 把数据处理部分加锁，把并⾏变成串⾏ 降低了效率，但是保证了数据安全 加锁⼀定记得开锁，或者直接⽤with lock:队列—Queue进程之间数据是隔离的，想实现进程间的数据通信，multiprocessing模块⽀持两种形式：队列和管道，这两种⽅式都是使⽤消息传递的⽣产者—消费者模型 ⽣产者：只负责⽣产，⽣产者把⽣产的东西放到队列中 消费者：只负责消费，队列中有⼀直消费，没有就等着import timefrom multiprocessing import Processfrom multiprocessing import Queuefrom multiprocessing import Lockclass PClass(Process): def __init__(self, name, lock, q): super().__init__() = name = lock self.q = q def run(self): while True: res = () print(res) print("name:", ) try: if res == "ok": # 接到完成信号，停⽌接受 break except Exception: print(1)class ProClass(Process): def __init__(self, name, q): super().__init__() = name self.q = q def run(self): for i in range(10): (1) (i) ("ok") # ⽣产者完成后，会发送完成信号if __name__ == '__main__': lock = Lock() q = Queue(10) pc = PClass("lynn", lock, q) pro = ProClass("fancy", q) () ()# ⽣产者把⽣产的数字加到队列中，消费者不停的从队列中去数字注意：

Queue(max)max数字，队列限制的最⼤数据量

(data)把数据data加到队列中

()取出队列中的数据

()队列中数据个数等于max时为True

()队列中为空时，等于True管道进程池进程利⽤的是计算机的多核优势，但是当进程过多时，效率反⽽受到影响，所以要对进程数量做限制。进程池：进程池可以指定数量的进程供⽤户调⽤，当有新的请求(进程)发起时，如果进程池满了，就等进程池中有进程结束，进⼊进程池。同步：import timefrom multiprocessing import Pooldef p_func(name): (1) print(name)if __name__ == '__main__': p = Pool(3) for i in range(5): (p_func, args=("lynnadsadasda",)) () print('w')注意：

apply()同步开启⼦进程，只有⼀个进程完成后，才会起下⼀个进程，返回值会⽴马返回。异步import timefrom multiprocessing import Pooldef p_func(name): (1) print(name) return 100if __name__ == '__main__': p = Pool(3) res_list = [] for i in range(5): res = _async(p_func, args=("lynnadsadasda",)) res_(res) () () for i in res_list: print(())

print('w')注意：

apply_async异步开启⼦进程 注意join()异步调⽤时必须加该⽅法，主进程运⾏完毕后，进程池中开启的⼦进程全部结束，所以要加该⽅法

close()⽅法必须在join()⽅法之前，意思是先关闭进程池，在等待

get()获取返回值，只有异步时才有该⽅法，同步没有