#队列 Queue：IPC相互通信，互相得到本来得不到的返回值。 #先进先出。 # from multiprocessing import Process,Queue # # def func(q): # q.put(1) #put可以放任意数据类型 # q.put([1,2,3]) # q.put('a') # print(q.full()) #已满，此处结果为T. 不准，多进程中异步的影响。 # q.put({'name':'alex'})#一共长度为3，第四个放不进去了，程序阻塞 # #等到被取出一个时，这个就能放进去了。 # try: # q.put_nowait() # except: # print('丢失了一个数据')#容错以后要写进去的数据将会丢失。 # # def func2(q): # print(q.get()) #拿一个少一个。 # print(q.get()) # print(q.get()) # print(q.get()) # # print(q.get()) #已经没有数据可取，程序阻塞，直到往里put了数据。 # try: # print(q.get_nowait()) #没有数据可取，不阻塞，但是报错，所以要try. # except: # print('已经没有数据了') # # # if __name__ == '__main__': # q = Queue(3) #数字表示可以放多长。 # p = Process(target=func,args=(q,)) # p.start() # p2 = Process(target=func2, args=(q,)) # p2.start() # # print(q.empty()) #不准，多进程中异步的影响。
#事件 Event 根据标志的真假来判断是否阻塞子进程。 # from multiprocessing import Process,Event # # def func(e): # print('阻塞前') # e.wait(3) #默认阻塞(F)，中间数字表示阻塞时间，但是状态依然还是F。 # print('通了') # # if __name__ == '__main__': # e = Event() # p = Process(target=func,args=(e,)) # p.start() # print(e.is_set())#判断wait是否为阻塞状态 # # e.set() #解除阻塞，使wait状态变为Ture # # e.clear()#使wait变成阻塞 #红绿灯： # import random # import time # from multiprocessing import Process,Event # # def trafic_light(e): # print(' 33[1;31m红灯亮 33[0m')#刚进来的时候wait默认F。肯定红灯，因为状态需要在下面if判断中修改。 # while True: # time.sleep(2) #等待车过来 # if e.is_set():#如果是非阻塞状态,肯定是先 # print(' 33[1;31m红灯亮 33[0m')#开红灯 # e.clear()#将wait变成阻塞状态 # else: # print(' 33[1;32m绿灯亮 33[0m')#如果是阻塞状态，开绿灯 # e.set()#将wait变为非阻塞状态 # # # def car(i,e): # if not e.is_set(): # print('%s正在等待通过' % i) # e.wait()#上面状态变为阻塞时，车无法通过。 # print('%s通过' % i) # # if __name__ == '__main__': # e = Event() # p1 = Process(target=trafic_light, args=(e,)) # p1.daemon = True#将红绿灯方法变成守护进程，随着主程序的结束而结束 # p1.start() # lis = [] # for i in range(10): # p = Process(target=car,args=(i,e)) # p.start() # time.sleep(random.randint(0, 3)) # lis.append(p) # for p_car in lis:p_car.join()#守护进程会随着car子进程的结束（主进程也结束）而结束
#信号量：semaphore 资源有限，有多个锁。 # from multiprocessing import Process,Semaphore # # def key(): # print('执行key') # # def func(s): # s.acquire() # key() # s.acquire() # key() # s.acquire() # key() #一共规定有三把钥匙，所以第四个不能执行了。 # s.acquire() # key() # # if __name__ == '__main__': # s = Semaphore(3) # p = Process(target=func,args=(s,)) # p.start() # import time # from multiprocessing import Process,Semaphore # # def ktv(i,s): # s.acquire() # print('%s进入ktv'%i) # time.sleep(0.2) # print('%s走了'%i) # s.release() # with s: #上下文管理，省略acquire和release # print('%s进入ktv'%i) # time.sleep(0.2) # print('%s走了'%i) # # if __name__ == '__main__': # s = Semaphore(4) # for i in range(10): # p = Process(target=ktv,args=(i,s)) # p.start()
#同步控制; #锁。Lock 用来防止多个进程在同一时间执行同一个代码。 #提高了安全性，但是降低了执行效率。效率是基于安全的基础上的，并发首先考虑的应该是安全，编码的过程中如果 #有不安全的情况，则必须要使用到锁。 #买票查票'str_dic['count'] -= 1,ppp.p.o-,njnjipni9miomiomiomimoiomiomim0oi;'. # import json # import time # from multiprocessing import Process,Lock # # def check_ticket(i): # with open('a') as f:str_dic = json.load(f) # print('%s正在查票，余票还有%s张'% (i,str_dic['count'])) # # def buy_ticket(i): # with open('a') as f:str_dic = json.load(f) # time.sleep(0.2) #模拟网络请求延迟,不要在打开文件缩进内睡，否则造成无法关闭文件，报错！ # if str_dic['count'] > 0: # str_dic['count'] -= 1 # print('%s买到票了'%i) # time.sleep(0.2)#模拟网络请求数据库延迟，也同样一定不要写在打开文件缩进内。 # with open('a',mode='w') as f1:json.dump(str_dic,f1) # # def ticket(lock,i): # # check_ticket(i) # # lock.acquire() # # buy_ticket(i) # # lock.release() # check_ticket(i) # with lock:buy_ticket(i) #上下文管理，省略拿钥匙和还钥匙步骤。 # # if __name__ == '__main__': # lock = Lock() # for i in range(10): # p = Process(target=ticket,args=(lock,i)) # p.start()
#守护进程(随着主进程代码的结束而结束) # import time # from multiprocessing import Process # # def protect_own(): # while True: # print('is alive') #循环打印，看什么时候结束。 # time.sleep(0.5) # # def son_process(): # for i in range(5): # print('第%s秒'%i)#正常执行，不会受主进程代码结束的影响。 # time.sleep(1) # # if __name__ == '__main__': # p_pro = Process(target=protect_own) # p_pro.daemon = True #默认为F，将子进程p_pro设置为守护进程。随主的代码结束而死。 # p_pro.start() # p_son = Process(target=son_process)#再设置一个普通的子进程。 # p_son.start()#此子进程不会随着主代码的结束而结束 # time.sleep(3)#在这睡一会儿，使守护进程可以顺利开启执行，防止顺序执行的太快。 # print(p_pro.is_alive())#主进程代码没有结束，肯定是T。 # # 普通的子进程p_son会正常执行完自己的，如何让守护进程等到p_son的结束才结束？： # p_son.join() #阻塞。这样下一句就会等到最后才执行，守护进程同样也会最后关闭。 # print('主进程代码结束！守护进程也跟着结束！') # p_pro.terminate()#手动关闭守护进程，但是操作系统需要一点时间才能关上 # time.sleep(3) #所以睡一会儿 # print(p_pro.is_alive())#此行代码也是主进程的代码，所以守护进程还是没有结束 #手动关闭后此行的结果就是F了。