并发编程4

守护进程 　　

　　语法：obj.daemon = True 　　　　必须放在obj.start()之前

　　特点：守护进程内无法在开启子进程，否则抛出异常。AssertionError: daemonic processes are not allowed to have children
　　　　   父进程代码执行结束守护进程也必须结束

from multiprocessing import Process
import time


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

if __name__ == '__main__':
    obj = Process(target=task, args=('egon',))
    obj.daemon=True
    obj.start()  # 发送信号给操作系统
    print('主')

互斥锁

　　强调：必须lock.acquire()一次，然后lock.release()释放一次，才能继续lock.acquire()，不能连续lock.acquire()

互斥锁和join的区别:
　　大前提：二者的原理都是一样，都是将并发变成串行，从而保证有序，

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

　　

from multiprocessing import Process,Lock
import time,random

mutex=Lock()

def task1(lock):
    lock.acquire() #
    print('task1:名字是egon')
    time.sleep(random.randint(1,3))
    print('task1:性别是male')
    time.sleep(random.randint(1,3))
    print('task1:年龄是18')
    lock.release()

def task2(lock):
    lock.acquire()
    print('task2:名字是alex')
    time.sleep(random.randint(1,3))
    print('task2:性别是male')
    time.sleep(random.randint(1,3))
    print('task2:年龄是78')
    lock.release()


def task3(lock):
    lock.acquire()
    print('task3:名字是lxx')
    time.sleep(random.randint(1,3))
    print('task3:性别是female')
    time.sleep(random.randint(1,3))
    print('task3:年龄是30')
    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()
    # p1.join()
    # p2.start()
    # p2.join()
    # p3.start()
    # p3.join()

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

　　区别二：互斥锁可以让一部分代码(修改共享数据的代码)串行，而join只能让代码整体串行

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

mutex=Lock()

def search():
    time.sleep(random.randint(1,3))
    with open('db.json','r',encoding='utf-8') as f:
        dic=json.load(f)
        print('%s 剩余票数:%s' %(os.getpid(),dic['count']))

def get():
    with open('db.json','r',encoding='utf-8') as f:
        dic=json.load(f)
    if dic['count'] > 0:
        dic['count']-=1
        time.sleep(random.randint(1,3))
        with open('db.json','w',encoding='utf-8') as f:
            json.dump(dic,f)
        print('%s 购票成功' %os.getpid())

def task(lock):
    search()
    lock.acquire()
    get()
    lock.release()

if __name__ == '__main__':
    for i in range(10):
        p=Process(target=task,args=(mutex,))
        p.start()
        # p.join()

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

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

IPC通信机制

　进程之间通信必须找到一种介质，该介质必须满足：
　　1，所有进程共享
　　2，必须是内存空间
　　附加：最好能够处理好所的问题

# from multiprocessing import Process,Manager,Lock
# import time
#
# mutex=Lock()
#
# def task(dic,lock):
#     lock.acquire()
#     temp=dic['num']
#     time.sleep(0.1)
#     dic['num']=temp-1
#     lock.release()
#
# if __name__ == '__main__':
#     m=Manager()
#     dic=m.dict({'num':10})
#
#     l=[]
#     for i in range(10):
#         p=Process(target=task,args=(dic,mutex))
#         l.append(p)
#         p.start()
#
#     for p in l:
#         p.join()
#     print(dic)


from multiprocessing import Queue

解决方案：

　　Queue:队列---先进先出

　　1.进程共享  2,内存空间  3.自动处理了锁定问题
　　强调：队列用来存放进程之间沟通的消息，数据量不应该过大

　　　　　maxsize的值超过内存限制就变得毫无意义

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

maxsize是队列中允许最大项数，省略则无大小限制。

主要方法：

1 q.put方法用以插入数据到队列中，put方法还有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常。
2 q.get方法可以从队列读取并且删除一个元素。同样，get方法有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出Queue.Empty异常。如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常.
3  
4 q.get_nowait():同q.get(False)
5 q.put_nowait():同q.put(False)
6 
7 q.empty():调用此方法时q为空则返回True，该结果不可靠，比如在返回True的过程中，如果队列中又加入了项目。
8 q.full()：调用此方法时q已满则返回True，该结果不可靠，比如在返回True的过程中，如果队列中的项目被取走。
9 q.qsize():返回队列中目前项目的正确数量，结果也不可靠，理由同q.empty()和q.full()一样

其他方法
1 q.cancel_join_thread():不会在进程退出时自动连接后台线程。可以防止join_thread()方法阻塞
2 q.close():关闭队列，防止队列中加入更多数据。调用此方法，后台线程将继续写入那些已经入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将调用此方法。关闭队列不会在队列使用者中产生任何类型的数据结束信号或异常。例如，如果某个使用者正在被阻塞在get()操作上，关闭生产者中的队列不会导致get()方法返回错误。
3 q.join_thread()：连接队列的后台线程。此方法用于在调用q.close()方法之后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread方法可以禁止这种行为

'''
multiprocessing模块支持进程间通信的两种主要形式:管道和队列
都是基于消息传递实现的,推荐队列接口
'''

from multiprocessing import Process,Queue
import time
q=Queue(3)


#put ,get ,put_nowait,get_nowait,full,empty
q.put(3)
q.put(3)
q.put(3)
print(q.full()) #满了

print(q.get())
print(q.get())
print(q.get())
print(q.empty()) #空了

生产者消费者模型

　　两类角色：
　　　　生产者：负责造数据的的任务比喻为生产者
　　　　消费者：接收生产者造出的数据来做进一步的处理，该类人物被比喻成消费者

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

　　什么时候使用生产这消费者模型：
　　　　程序中出现明显的两类任务，一类任务负责生产，一类任务负责处理生产的数据

　　好处：
　　　　1，实现了生产者和消费者解耦合
　　　　2，平衡了生产力和消费力，彼此互不影响，即生产可以不停的生产，消费者可以不停消费，二者互相不沟通，只和队列沟通

from multiprocessing import Process,Queue
import time,random,os
def consumer(q):
    while True:
        res=q.get()
        time.sleep(random.randint(1,3))
        print('33[45m%s 吃 %s33[0m' %(os.getpid(),res))

def producer(q):
    for i in range(10):
        time.sleep(random.randint(1,3))
        res='包子%s' %i
        q.put(res)
        print('33[44m%s 生产了 %s33[0m' %(os.getpid(),res))

if __name__ == '__main__':
    q=Queue()
    #生产者们:即厨师们
    p1=Process(target=producer,args=(q,))

    #消费者们:即吃货们
    c1=Process(target=consumer,args=(q,))

    #开始
    p1.start()
    c1.start()
    print('主')

#生产者消费者模型总结

    #程序中有两类角色
        一类负责生产数据（生产者）
        一类负责处理数据（消费者）
        
    #引入生产者消费者模型为了解决的问题是：
        平衡生产者与消费者之间的工作能力，从而提高程序整体处理数据的速度
        
    #如何实现：
        生产者<-->队列<——>消费者
    #生产者消费者模型实现类程序的解耦和