py6.12

#队列 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了。