并发编程

互斥锁 ：

• 进程数据不共享，但是共享同一套文件系统；

• 同一个打印终端,是没有问题的,而共享带来的是竞争，竞争带来的结果就是错乱

• 互斥锁的意思就是互相排斥，如果把多个进程比喻为多个人，互斥锁的工作原理就是多个人都要去争抢同一个资源

• 互斥锁的原理，就是把并发改成穿行，降低了效率，但保证了数据安全不错乱

from multiprocessing import Process,Lock
import os , time

def wprk(lock):
    lock.acquire()  #枷锁
    print(f'{os.getpid} is running')
    time.sleep(2)
    print(f'{os.getpid} is done')
    lock.release()  #开锁
if __name__ == '__main__':
    lock =Lock()
    for i in range(3):
        P = Process(target = work,args=(lock,))
        p.start()

• 并发运行，效率高，但竞争写同一文件，数据写入错乱

• 加锁处理：由并发变成了串行，牺牲了运行效率，但保证了数据安全

• 使用join将并发改成穿行，确实能保证数据安全，但问题是连查票操作也变成只能一个一个人去查了，很明显大家查票时应该是并发地去查询而无需考虑数据准确与否，此时join与互斥锁的区别就显而易见了，join是将一个任务整体串行，而互斥锁的好处则是可以将一个任务中的某一段代码串行

• 加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行地修改，没错，速度是慢了，但牺牲了速度却保证了数据安全

• 队列和管道都是将数据存放于内存中，而队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，因而队列才是进程间通信的最佳选择。

• 我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性

队列：

- 进程彼此之间互相隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的 -创建队列的类（底层就是以管道和锁定的方式实现）：

Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递

1. q.put方法用以插入数据到队列中。

2. q.get方法可以从队列读取并且删除一个元素

from multiprocessing import Process,Queue

q= Queue(3)
#put ,get ,put_nowait,get_nowait,full,empty
q.put(1)
q.put(2)
q.put(3)
print(q.full()) #满了
# q.put(4) #再放就阻塞住了
print(q.get())
print(q.get())
print(q.get())
print(q.empty()) #空了
# print(q.get()) #再取就阻塞住了

生产者与消费者：

- 生产者指的是生产数据的任务，消费者指的是处理数据的任务

• 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力

• 阻塞队列就是用来给生产者和消费者解耦的

from multiprocessing import  Process,JoinableQueue
import time,random,os
def consumer(q,name):
    while True:
        res = q.get()
        time.sleep(random.randint(1,3))
        print(f'\033[43m{name} 吃 {res}\033]')
        q.task_done()   # --发送给q.join()说明已经从队列中取走一个数据并处理完毕了
        
        
def producer(q,name,food):
    for i in range(3):
        time.sleep(random.randint(1,3))
        res = f'{food}{i}'
        q.put(res)
    
    q.join() #等到消费者把自己放入队列中的所有的数据都取走之后，生产者才结束
if __name__ == '__main__':
    q = JoinbleQueue()
     #生产者们:即厨师们
    p1=Process(target=producer,args=(q,'egon1','包子'))
    p2=Process(target=producer,args=(q,'egon2','骨头'))
    p3=Process(target=producer,args=(q,'egon3','泔水'))
    #消费者们:即吃货们
    c1=Process(target=consumer,args=(q,'alex1'))
    c2=Process(target=consumer,args=(q,'alex2'))
    c1.daemon=True
    c2.daemon=True
    #开始
    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()
    p1.join()
    p2.join()
    p3.join()
    #1、主进程等生产者p1、p2、p3结束
    #2、而p1、p2、p3是在消费者把所有数据都取干净之后才会结束
    #3、所以一旦p1、p2、p3结束了，证明消费者也没必要存在了，应该随着主进程一块死掉，因而需要将生产者们设置成守护进程
    print('主')
    

原文：https://www.cnblogs.com/shaozheng/p/11719900.html