python全栈脱产第35天------IPC机制、生产者消费者模型、线程、

一、进程间的通信（IPC机制）

　　通过管道或是队列（管道加锁）

　　导入Queue模块来进行通信

二、生产者消费者模型

　　定义：生产者：代指生产数据的任务

　　　　　消费者：代指处理数据的任务

　　工作方式：生产生产数据传递消费者处理

　　实现方式：生产者--->队列<---消费者

　　用途：当程序中出现明显的两类任务，一类负责生产，一类负责处理数据，就可以引入生产者消费者模型来实现

　　用法：

import time,random
from multiprocessing import Process,JoinableQueue

def producer(name,food,q):
    for i in range(3):
        res='%s%s' %(food,i)
        time.sleep(random.randint(1,3)) #模拟生产数据的时间
        q.put(res)
        print('厨师[%s]生产了<%s>' %(name,res))

def consumer(name,q):
    while True:
        res=q.get()
        time.sleep(random.randint(1,3)) #模拟处理数据的时间
        print('吃货[%s]吃了<%s>' %(name,res))
        q.task_done()

if __name__ == '__main__':
    q=JoinableQueue()
    # 生产者们
    p1=Process(target=producer,args=('小Egon','泔水',q))
    p2=Process(target=producer,args=('中Egon','屎包子',q))
    p3=Process(target=producer,args=('大Egon','腰子汤',q))
    # 消费者们
    c1=Process(target=consumer,args=('刘清正',q))
    c2=Process(target=consumer,args=('吴三江',q))
    c1.daemon=True
    c2.daemon=True

    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()

    p1.join()
    p2.join()
    p3.join()
    q.join() # 主进程等q结束,即q内数据被取干净了
    print('主')
三、线程
　　定义：进程其实是一个资源单位，而进程内的线程才是cpu上的执行单位　　线程就是指代码的执行过程
　　与进程的区别：1.同一个进程下的多个线程共享进程内的资源　　2.创建线程的开销要远远小于进程
　　开启进程的两种方式：
　　1.方式一：

from threading import Thread
import time

def task(name):
    print('%s is running' %name)
    time.sleep(2)
    print('%s is done' %name)

if __name__ == '__main__':
    t=Thread(target=task,args=('线程1',))
    t.start()
    print('主')
　　2.方式二：

from threading import Thread
import time

class Mythread(Thread):
    def run(self):
        print('%s is running' %self.name)
        time.sleep(2)
        print('%s is done' %self.name)

if __name__ == '__main__':
    t=Mythread()
    t.start()
    print('主')
　　线程互斥锁：

from threading import Thread,Lock
import time

mutex=Lock()
n=100
def task():
    global n
    mutex.acquire()
    temp=n
    time.sleep(0.1)
    n=temp-1
    mutex.release()

if __name__ == '__main__':
    t_l=[]
    for i in range(100):
        t=Thread(target=task)
        t_l.append(t)
        t.start()

    for t in t_l:
        t.join()
    print(n)