内容大纲： Process开启子进程 #另外一种开启子进程的方式 #join控制子进程 #守护进程 同步控制 #锁 Lock #信号量 Samphore #事件 Event
#join控制子进程#p.join() 阻塞p进程，p进程执行结束，才结束阻塞。import timeimport randomfrom multiprocessing import Processdef func(index): time.sleep(random.random()) print(‘第%s个邮件已经发送完毕‘%index)
if __name__ == ‘__main__‘: for i in range(10): Process(target=func,args=(i,)).start() print(‘10个邮件已经发送完毕‘)
10个邮件已经发送完毕第2个邮件已经发送完毕第5个邮件已经发送完毕第8个邮件已经发送完毕第6个邮件已经发送完毕第1个邮件已经发送完毕第7个邮件已经发送完毕第0个邮件已经发送完毕第9个邮件已经发送完毕第3个邮件已经发送完毕第4个邮件已经发送完毕
#发送10 个邮件编程了同步事件 就是一个执行了在执行另一个import timeimport randomfrom multiprocessing import Processdef func(index): time.sleep(random.random()) print(‘第%s个邮件已经发送完毕‘%index)
if __name__ == ‘__main__‘: p_list = [] for i in range(10): p = Process(target=func,args=(i,)) p_list.append(p) for p in p_list: p.start() p.join() #开启一个进程，进程结束之后再开启下一个进程， print(‘10个邮件已经发送完毕‘)第0个邮件已经发送完毕第1个邮件已经发送完毕第2个邮件已经发送完毕第3个邮件已经发送完毕第4个邮件已经发送完毕第5个邮件已经发送完毕第6个邮件已经发送完毕第7个邮件已经发送完毕第8个邮件已经发送完毕第9个邮件已经发送完毕10个邮件已经发送完毕
#怎样才能够实现，10个邮件并发进行，等到是个邮件都完成发送，再汇报10个有家你已经发送完毕？？？
import timeimport randomfrom multiprocessing import Processdef func(index): time.sleep(random.random()) print(‘第%s个邮件已经发送完毕‘%index)
if __name__ == ‘__main__‘: p_list = [] for i in range(10): p = Process(target=func,args=(i,)) p.start() p_list.append(p) #告诉操作系统开启10 个进程 #把10个进程放进一个列表 for p in p_list: p.join()#p_list里面的进程当做一个整体，这个证题里面的都执行完了，再进行主进程#但是p_list中的是个进程是并发的
print(‘10个邮件已经发送完毕‘)
第2个邮件已经发送完毕第4个邮件已经发送完毕第3个邮件已经发送完毕第1个邮件已经发送完毕第9个邮件已经发送完毕第0个邮件已经发送完毕第6个邮件已经发送完毕第5个邮件已经发送完毕第7个邮件已经发送完毕第8个邮件已经发送完毕10个邮件已经发送完毕
#调用类方法，开启进程from multiprocessing import Processimport osclass MyProcess(Process):#继承Process类 def run(self): print(‘子进程：‘,os.getpid(),os.getppid())if __name__ == ‘__main__‘: p = MyProcess()#实例化对象 p.start()#启动进程
子进程： 10208 8564
#调用类方法，开启进程的方法，怎么给进程传递参数？？？from multiprocessing import Processimport osclass MyProcess(Process): def __init__(self,args): super().__init__()#调用父类的初始化方法 self.args = args#传入参数
def run(self): print(‘子进程：‘,os.getpid(),os.getppid(),self.args)if __name__ == ‘__main__‘: p = MyProcess(‘参数‘) p.start() #开启一个进程的时候调用的是这个类的run方法 print(‘主进程：‘,os.getpid(),os.getppid())主进程： 6804 7136子进程： 9668 6804 参数
#守护进程deamon#某个进程设置成守护进程 已经要在他开始之前import os,timefrom multiprocessing import Processdef func(): print(‘子进程start‘) time.sleep(3) print(‘子进程 end‘)if __name__ == ‘__main__‘: p = Process(target=func) p.daemon = True#主进程结束不会等待子进程， p.start() time.sleep(2) print(‘主进程‘)
子进程start主进程
#为什么会出现子进程没有执行结束，主进程就结束完毕 #正常情况下，主进程会等待子进程的结束，才会结束，最后给子进程回收资源 #守护进程会随着主进程的结束 而提前结束
#守护进程的举例#如果主程序的代码已经执行完毕，但是子进程代码还没有执行完，守护进程都不会继续执行import time,os,randomfrom multiprocessing import Processdef func1(): count = 1 while True: time.sleep(0.5) print(count*‘*‘) count += 1
def func2(): print(‘func2 start‘) time.sleep(5) print(‘func2 end‘)
if __name__ == ‘__main__‘: p1 = Process(target=func1) p1.daemon = True p1.start()
p2 = Process(target=func2) p2.start() time.sleep(3) print(‘主进程‘)
func2 start***主进程func2 end
#守护进程的应用：程序的报活 每隔5分钟向主机汇报自己的运行状况
#锁的应用#买车票import json,timefrom multiprocessing import Processdef search(person): with open(‘ticket.txt‘) as f : dic = json.load(f) time.sleep(0.2) print(‘%s查询余票：%s‘%(person,dic[‘count‘]))def get_ticket(person): with open(‘ticket.txt‘) as f : dic =json.load(f) time.sleep(0.2) if dic[‘count‘] >0 : print(‘%s 买到票了‘%person) dic[‘count‘] -= 1 time.sleep(0.2) with open(‘ticket.txt‘,‘w‘) as f : json.dump(dic,f) else: print(‘%s没有买到票‘%person)if __name__ == ‘__main__‘: for i in range(10): p = Process(target=get_ticket,args=(‘person :%s‘%i,)) p.start()
ticket.txt文本里面的内容：{"count": 3}
person :9 买到票了person :2 买到票了person :5 买到票了person :7 买到票了person :4 买到票了person :6 买到票了person :1 买到票了person :8 买到票了person :0 买到票了person :3 买到票了
ticket.txt文本里面的内容最后修改为：{"count": 1}#为什么明明只有3张票 结果却显示都买到票了？？？
#异步的情况下，多个进程可能同时修改同一份资源#为了保证数据的安全，需要引入锁的概念#给这个修改的过程加锁
#加锁的效果 降低了程序的执行效率 让原来是同时执行的代码变成了顺序执行，异步变成同步 但是保证了数据的安全
#买票的例子#文件信息： ticket.txt:{"count": 3}import json,timefrom multiprocessing import Process,Lockdef search(person): with open(‘ticket.txt‘) as f : dic = json.load(f) time.sleep(0.2) print(‘%s查询余票：%s‘%(person,dic[‘count‘]))def get_ticket(person): with open(‘ticket.txt‘) as f : dic =json.load(f) time.sleep(0.2) if dic[‘count‘] >0 : print(‘%s买到票了‘%person) dic[‘count‘] -= 1 time.sleep(0.2) with open(‘ticket.txt‘,‘w‘) as f : json.dump(dic,f) else: print(‘%s没有买到票‘%person)
def ticket(person,lock): search(person) lock.acquire() get_ticket(person)#给买票的过程上锁 lock.release()if __name__ == ‘__main__‘: lock = Lock() for i in range(10): p = Process(target=ticket,args=(‘person :%s‘%i,lock))#这里有个坑逗号不能少 p.start()#文件修改为： ticket.txt:{"count": 0}person :9查询余票：3person :4查询余票：3person :9买到票了person :7查询余票：3person :0查询余票：3person :2查询余票：3person :4买到票了person :6查询余票：2person :3查询余票：2person :5查询余票：2person :1查询余票：2person :8查询余票：2person :7买到票了person :0没有买到票person :2没有买到票person :6没有买到票person :3没有买到票person :5没有买到票person :1没有买到票person :8没有买到票
#并发执行的例子
import timefrom multiprocessing import Processdef func(num): time.sleep(1) print(‘并发执行‘,num)
if __name__ == ‘__main__‘: for i in range(10): p = Process(target= func,args=(i,)) p.start()并发执行 4并发执行 0并发执行 5并发执行 1并发执行 2并发执行 3并发执行 7并发执行 6并发执行 9并发执行 8
#锁的例子#谁先拿到锁 谁就先进入 同步的程序import timefrom multiprocessing import Process,Lockdef func(num,lock): time.sleep(1) print(‘异步执行‘,num)
lock.acquire() time.sleep(0.5) print(‘ 同步执行‘,num) lock.release()
if __name__ == ‘__main__‘: lock = Lock() for i in range(10): p = Process(target= func,args=(i,lock)) p.start()异步执行 0异步执行 5异步执行 7异步执行 3 同步执行 0异步执行 8异步执行 4异步执行 1异步执行 6异步执行 2异步执行 9 同步执行 5 同步执行 7 同步执行 3 同步执行 8 同步执行 4 同步执行 1 同步执行 6 同步执行 2 同步执行 9#插入图片#############
#以上的的锁的概念 都是互斥锁的概念
from multiprocessing import Process,Locklock = Lock()
lock.acquire()print(‘456‘)#lock没有归还程序阻塞
lock.acquire()print(‘123‘)lock.release()
--->456
#信号量能够同时提供服务的最大数量#插入图片########################没有归还钥匙的情况import time,randomfrom multiprocessing import Process,Semaphoredef ktv(person,sem): sem.acquire() print(‘%s走进ktv‘%person) time.sleep(random.randint(1,3)) print(‘ %s走出ktv‘%person) #没有归还钥匙，四个钥匙被取走之后，程序被阻塞if __name__ == ‘__main__‘: sem = Semaphore(4)#信号量设置成4 for i in range(10): p = Process(target=ktv,args=(‘person:%s‘%i,sem)) p.start()
person:0走进ktvperson:3走进ktvperson:9走进ktvperson:2走进ktv person:9走出ktv person:0走出ktv person:2走出ktv person:3走出ktv
#归还钥匙import time,randomfrom multiprocessing import Process,Semaphoredef ktv(person,sem): sem.acquire() print(‘%s走进ktv‘%person) time.sleep(random.randint(1,3)) print(‘ %s走出ktv‘%person) sem.release()if __name__ == ‘__main__‘: sem = Semaphore(4)#信号量设置成4 for i in range(10): p = Process(target=ktv,args=(‘person:%s‘%i,sem)) p.start()person:1走进ktvperson:5走进ktvperson:3走进ktvperson:8走进ktv person:1走出ktvperson:0走进ktv person:3走出ktvperson:6走进ktv person:8走出ktvperson:4走进ktv person:5走出ktvperson:7走进ktv person:6走出ktvperson:2走进ktv person:0走出ktvperson:9走进ktv person:7走出ktv person:2走出ktv person:4走出ktv person:9走出ktv控制信号量的机制： 计数器+锁
#什么是事件？？ 让事件暂停，叫做阻塞事件： 调用wait()方法 wait()是否能够阻塞，需要进一步看事件event内部的属性 控制event的属性： set()将属性的值改成True clear()将属性的值改成False is_set() 判断当前的属性是否是True
#交通信号灯import time,randomfrom multiprocessing import Process,Event
def traffic_light(e):
while True: if e.is_set(): time.sleep(2) print(‘\033[31m红灯亮了\033[0m‘) e.clear() else: time.sleep(2) print(‘\033[32m绿灯亮了\033[0m‘) e.set()
def car(e,i): if not e.is_set(): print(‘car:%s在等待‘%i) e.wait() print(‘car:%s通过了‘%i)
if __name__ == ‘__main__‘: e = Event() p = Process(target=traffic_light,args=(e,)) p.daemon = True #设置成守护进程 p.start() p_list = [] for i in range(20): time.sleep((random.randrange(0,3,2))) p = Process(target=car,args=(e,i)) p.start() p_list.append(p) for i in p_list:i.join()car:0在等待car:1在等待car:2在等待绿灯亮了car:0通过了car:1通过了car:2通过了car:3通过了红灯亮了car:4在等待绿灯亮了car:4通过了car:5通过了红灯亮了car:6在等待绿灯亮了car:6通过了car:7通过了红灯亮了car:8在等待绿灯亮了car:8通过了car:9通过了红灯亮了绿灯亮了car:10通过了car:11通过了car:12通过了car:14通过了car:13通过了红灯亮了car:16在等待car:15在等待绿灯亮了car:15通过了car:16通过了car:18通过了car:17通过了红灯亮了car:19在等待绿灯亮了car:19通过了
原文地址：https://www.cnblogs.com/cavalier-chen/p/9678236.html
时间： 2024-11-05 21:53:41