并发编程，进程

守护进程：

什么是守护进程那，守护进程就像太监一样，一直守护皇上，等皇帝死了，他也要陪葬

保随主进程一生，主进程死了，都给死

from multiprocessing import Process


def run(name):
    print('%s is runing'%name)

if __name__ == '__main__':
    p=Process(target=run,args=('young friend',))
    # p.daemon = True
    p.start()
    print('主===》')#主===》
                    #young friend is runing


def run(name):
    print('%s is runing'%name)

if __name__ == '__main__':
    p=Process(target=run,args=('young friend',))
    p.daemon = True
    p.start()
    print('主===》')#主===》

互斥锁：

在多个子进程 诞生的时候 哪个子进程先抢到这个锁  哪个子进程就可以先执行（这个锁每次只能一个人用，进程结束后，会自动释放）

from multiprocessing import Process,Lock
#用join实现串行
def task1():
    print('任务一，姓名：egon')
    print('任务一，年龄，18')
    print('任务一，性别：男')

def task2():
    print('任务二，姓名：alex')
    print('任务二，年龄，78')
    print('任务二，性别：男')


def task3():
    print('任务三，姓名：lxx')
    print('任务三，年龄，38')
    print('任务三，性别：男')


if __name__ == '__main__':
    p1=Process(target=task1)
    p2 = Process(target=task2)
    p3 = Process(target=task3)

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



#用互斥锁实现串行
mutex=Lock()
def task1(Lock):
    Lock.acquire()
    print('任务一，姓名：egon')
    print('任务一，年龄，18')
    print('任务一，性别：男')
    Lock.release()

def task2(Lock):
    Lock.acquire()
    print('任务二，姓名：alex')
    print('任务二，年龄，78')
    print('任务二，性别：男')
    Lock.release()


def task3(Lock):
    Lock.acquire()
    print('任务三，姓名：lxx')
    print('任务三，年龄，38')
    print('任务三，性别：男')
    Lock.release()


if __name__ == '__main__':
    p1=Process(target=task1,args=(mutex,))
    p2 = Process(target=task2,args=(mutex,))
    p3 = Process(target=task3,args=(mutex,))

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

互斥锁与join的区别

大前提：二者的原理都一样，都是将并发变成串行，从而保证有序

区别:join是按照人为指定的顺序执行，而互斥锁是进程平等地竞争，谁先抢到谁执行

     互斥锁可以让一部分代码（修改共享数据的代码）串行，而join只能将代码整体串行

模拟购票系统

from multiprocessing import Process,Lock
import time,random,json,os

x=Lock()

def select():
    time.sleep(random.randint(1, 3))
    dic=json.load(open('a.txt','r'))
    print('%s票还剩余%s张'%(os.getpid(),dic['count']))


def get():
    dic = json.load(open('a.txt', 'r'))
    if dic['count']>0:
       dic['count']-=1
       time.sleep(random.randint(1, 3))
       json.dump(dic,open('a.txt','w'))
       print('%s抢票成功'%os.getpid())


def lock_(Lock):
    select()
    Lock.acquire()
    get()
    Lock.release()

if __name__ == '__main__':
    for i in range(10):
        p=Process(target=lock_,args=(x,))
        p.start()

ICP通信机制：

进程之间通信必须找到一种介质，该介质必须满足，

1.是所有进程共享的

2.必须是内存空间

from multiprocessing import Queue

# 对列：
#1、共享的空间
#2、是内存空间
#3、自动帮我们处理好锁定问题
q=Queue(3)
q.put('first')
q.put({'second':None})
q.put('三')

# q.put(4) #阻塞
print(q.get())
print(q.get())
print(q.get())

强调：

1.队列用来存成进程之间沟通的信息，数据量不应该过大

2.maxsize的值超过的内存限制就变的毫无意义了

生产者消费者模型
该模型中包含两类重要的角色：
1、生产者：将负责造数据的任务比喻为生产者
2、消费者：接收生产者造出的数据来做进一步的处理，该类人物被比喻成消费者

 实现生产者消费者模型三要素
1、生产者
2、消费者
3、队列

 什么时候用该模型：
程序中出现明显的两类任何，一类任务是负责生产，另外一类任务是负责处理生产的数据的

 该模型的好处：
 1、实现了生产者与消费者解耦和
 2、平衡了生产力与消费力，即生产者可以一直不停地生产，消费者可以不停地处理，因为二者
不再直接沟通的，而是跟队列沟通

import time
import random
from multiprocessing import Process,Queue

def consumer(name,q):
    while True:
        res=q.get()
        time.sleep(random.randint(1,3))
        print('33[46m消费者===》%s 吃了 %s33[0m' %(name,res))


def producer(name,q,food):
    for i in range(5):
        time.sleep(random.randint(1,2))
        res='%s%s' %(food,i)
        q.put(res)
        print('33[45m生产者者===》%s 生产了 %s33[0m' %(name,res))


if __name__ == '__main__':
    #1、共享的盆
    q=Queue()

    #2、生产者们
    p1=Process(target=producer,args=('egon',q,'包子'))
    p2=Process(target=producer,args=('刘清政',q,'泔水'))
    p3=Process(target=producer,args=('杨军',q,'米饭'))

    #3、消费者们
    c1=Process(target=consumer,args=('alex',q))
    c2=Process(target=consumer,args=('梁书东',q))


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