进程开启，join,进程几个方法，互斥锁,队列，生产者消费者模型

from multiprocessing import Process

def run(args):
    print(args)

if __name__=='__main__':
    p1=Process(target=run,args=('hah',))
    p2 = Process(target=run, args=('helloh',))
    p3 = Process(target=run, args=('ego',))  必须加逗号

    p1.start()
    p2.start()
    p3.start()

class Myoprocess(Process):继承进程类属性
    def __init__(self,name):
        super().__init__()  继承初始的属性方法
        self.name=name
    def run(self):
        print(self.name)
if __name__=='__main__':
    p1=Myoprocess('EGON')

    p1.start()自动调用run函数
经典类是一种没有继承的类，实例类型都是type类型，如果经典类被作为父类，子类调用父类的构造函数时会返回
join 是优先执行子进程，执行完毕在执行主进程，几个子进程同时用join先并发这几个再执行主进程
process_list=[p1,p2,p3,p4]
for i in process_list:
i.start()
i.join()


is_alive  terminate 关闭进程

3 p.terminate():强制终止进程p，不会立即关闭 马上查看存活状态可能还是存活不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。
如果p还保存了一个锁那么也将不会被释放，进而导致死锁

守护进程
p1.daemon=True  一定在start前设置
父进程结束子进程也就结束


互斥锁、Lock

import  json,time
def search(i):
    time.sleep(1)
    print('%s等待购票' % i)
    return 
def buy(i):
    with open('piao.txt','rb')as f:
        dict1=f.read()
    dict1=json.loads(dict1.decode('utf-8'))
    if dict1['yupiao']>=1:
        dict1['yupiao']-=1
        with open('piao.txt', 'wb')as f:
            f.write(json.dumps(dict1).encode('utf-8'))
            print('%s购票成功,余票%s'%(i,dict1['yupiao']))
    else:
        print('余票不足')


def task(i,lock):
    search(i)
    lock.acquire()
    buy(i)
    lock.release()
if __name__=='__main__':
    for i in range(1,100):
       lock=Lock()
       p1=Process(target=task,args=(i,lock))
       p1.start()

死锁原因

def task1(l1,l2,i):
    l1.acquire()
    print("盘子被%s抢走了" % i)
    time.sleep(1)


    l2.acquire()
    print("筷子被%s抢走了" % i)
    print("吃饭..")
    l1.release()
    l2.release()


    pass

def task2(l1,l2,i):

    l2.acquire()
    print("筷子被%s抢走了" % i)

    l1.acquire()
    print("盘子被%s抢走了" % i)

    print("吃饭..")
    l1.release()
    l2.release()


if __name__ == '__main__':
    l1 = Lock()
    l2 = Lock()
    Process(target=task1,args=(l1,l2,1)).start()
    Process(target=task2,args=(l1,l2,2)).start()
这个是没有释放，然后被另一个堵住，另一个需要这个进程来释放，     也有可能一个锁两次用

q=Queue(3)
q.put('sb周周')
q.put('sb总则')
q.put('sb总')
q.put('sb则',False)加False后满了报异常  取不出来报异常，不加的话满了或者空了会阻塞
print(q.get())

生产者消费者模型
用队列实现缓冲，生产者扔给队列，满了阻塞，消费者处理空了等待

def eat(q,name):
    while True: 循环关闭不了进程所以给一个标志值，发现后break，然后用串行join和守护进程来关闭，或者直接return（low）
        time.sleep(random.randint(1,3))
        res=q.get()
        if res==None:
            return 
        else:
          print('%s吃了第%s'%(name,res))
     
def make(q,name,food):
    for i in range(6):
       time.sleep(random.randint(1, 3))
       res=(i,"个",food)
       q.put(res)
       print('%s做了第%s个%s'%(name,i,food))
    q.put(None)

if __name__=='__main__':
    q=Queue()
    p1=Process(target=make,args=(q,'egon','热狗'))
    p1.daemon = True
    p1.start()

    p2 = Process(target=make, args=(q, 'alex', '面包'))
    p2.daemon = True
    p2.start()

    m2 = Process(target=eat, args=(q, '思聪',))

    m2.start()
    p1.join()
    p2.join()
    m2.join()
    print('zhu')

有内置的实现

def eat(q,name):
    while True:
        time.sleep(random.randint(1,3))
        res=q.get()
        print('%s吃了第%s' % (name, res))
        q.task_done()
告诉生产者拿完了

def make(q,name,food):
    for i in range(6):
       time.sleep(random.randint(1, 3))
       res=(i,"个",food)
       q.put(res)
       print('%s做了第%s个%s'%(name,i,food))
    q.join()  等消费者拿完了自己结束











if __name__=='__main__':
    q=JoinableQueue()
    p1=Process(target=make,args=(q,'egon','热狗'))
    p1.start()

    p2 = Process(target=make, args=(q, 'alex', '面包'))
    p2.start()

    m2 = Process(target=eat, args=(q, '思聪',))
    m2.daemon=True 生产者等消费者拿完，结束消费者等生产者结束，主线程结束，自己结束
    m2.start()
    p1.join()
    p2.join()
    print('zhu')