python 并发之进程

 1 import time,json
 2 from multiprocessing import Process,Lock
 3 
 4 def show_t(i):
 5     f = open('ticket', mode='r',encoding='utf-8')
 6     dic = json.load(f)
 7     print('%s查询剩余票数为%s'%(i,dic['count']))
 8 def get_t(i,l1):
 9     l1.acquire()
10     f = open('ticket', mode='r', encoding='utf-8')
11     dic = json.load(f)
12     if dic['count'] > 0:
13         dic['count'] -= 1
14         print('%s抢票成功'%i)
15         time.sleep(0.2)
16         f = open('ticket',mode= 'w',encoding='utf-8')
17         json.dump(dic,f)
18     else:
19         print('没票了')
20     l1.release()
21 if __name__ == '__main__':
22     l1 = Lock()
23     for i in range(10):
24         p1 = Process(target=show_t,args=(i,))
25         p1.start()
26 
27     for i in range(10):
28         p2 = Process(target=get_t,args=(i,l1))
29         p2.start()

#加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。
虽然可以用文件共享数据实现进程间通信，但问题是：
1.效率低（共享数据基于文件，而文件是硬盘上的数据）
2.需要自己加锁处理

#因此我们最好找寻一种解决方案能够兼顾：1、效率高（多个进程共享一块内存的数据）2、帮我们处理好锁问题。这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。
队列和管道都是将数据存放于内存中
队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，
我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。

IPC通信机制（了解）：IPC是intent-Process Communication的缩写，含义为进程间通信或者跨进程通信，是指两个进程之间进行数据交换的过程。IPC不是某个系统所独有的，任何一个操作系统都需要有相应的IPC机制，
比如Windows上可以通过剪贴板、管道和邮槽等来进行进程间通信，而Linux上可以通过命名共享内容、信号量等来进行进程间通信。Android它也有自己的进程间通信方式，Android建构在Linux基础上，继承了一
部分Linux的通信方式。

 1 import time
 2 from multiprocessing import Process
 3 
 4 def f1():
 5     time.sleep(3)
 6     print('xxxx')
 7 
 8 def f2():
 9     time.sleep(5)
10     print('我是普通子进程')
11 
12 if __name__ == '__main__':
13     p1 =Process(target=f1,)
14     p1.daemon = True  # 将该进程设置为守护进程,必须写在start之前,意思如果我的主进程代码运行结束了,你这个子进程不管运行到什么地方,都直接结束
15     p1.start()
16     # 开启一个普通的子进程来验证一下守护进程的结束只和主进程的代码运行结束有关系,而整个程序的结束需要主进程和普通的子进程的代码都运行结束才结束
17     p2 = Process(target=f2,)
18     p2.start()
19     # 等待2号普通进程的结束,才继续执行下面主进程的代码
20     # p2.join()
21     # 守护进程会跟着父进程的代码运行结束,就结束
22     print('我是主进程')

 1 from multiprocessing import Process,Queue
 2 q = Queue(3)  # 创建一个队列队形,队列长度为3,先进先出
 3 q.put(1)
 4 print('>>>>',q.qsize()) # 返回当前队列的内容长度
 5 print(q.full())
 6 q.put(2)
 7 print('>>>>',q.qsize())
 8 q.put(3)
 9 print(q.full())  # q.full()了解,因为这个东西不可靠,满了返回一个True,不满返回一个False
10 # print('sss')
11 # q.put(4)  # 放入数据的时候,如果队列满了,程序会在你put操作的地方阻塞
12 try:
13     q.put_nowait(4)  # 不阻塞程序,但是会报错queue.Full,可以通过捕获异常来进行其他的操作
14 except:
15     print('队列满了,玩别的去吧')
16 
17 print('xxx')
18 
19 print(q.get())
20 print(q.get())
21 print(q.get())
22 print('是不是空了呀:',q.empty())  # q.empty()了解,因为这个东西不可靠,空了返回一个True,不空返回False
23 q.put(4)
24 print('是不是空了呀:',q.empty())   # True或者False,因为q在put数据的时候,有一个细微的延迟回一个False
25 print(q.get())  # 如果队列空了,程序会在这个地方卡主,也就是阻塞程序
26 try:
27     q.put_nowait()  # queue.Empty
28 except:
29     print('队列空了,搞别的事情')
30 
31 print('队列拿完了')

from multiprocessing import Process,Queue

def f1(q):
    q.put('约吗?')

if __name__ == '__main__':
    q = Queue(3)
    p =Process(target=f1,args=(q,))
    p.start()

    son_p_msg = q.get()

    print('来自子进程的消息:',son_p_msg)

 1 import time
 2 from multiprocessing import Process,JoinableQueue
 3 
 4 # 生产者
 5 def producer(q):
 6     for i in range(10):
 7         time.sleep(0.7)
 8         s = '大包子%s号'%i
 9         print(s+'新鲜出炉')
10         q.put(s)
11     q.join() # 就等着task_done()信号的数量.和我put进去的数量想同时,才继续执行
12     print('所有任务都被处理了,继续前行吧少年们')
13 
14 
15 def consumer(q):
16     while 1:
17         time.sleep(0.2)
18         baozi =q.get()
19 
20         print(baozi+'被吃了')
21         q.task_done()  # 给队列发送一个取出的这个任务已经处理完毕的信号
22 
23 
24 if __name__ == '__main__':
25     q = JoinableQueue(10)
26     pro_p = Process(target=producer,args=(q,))
27     con_p = Process(target=consumer,args=(q,))
28     pro_p.start()
29     con_p.daemon = True  # 守护进程
30     con_p.start()
31 
32     pro_p.join()
33     print('主进程结束')