并发编程（day34）

1.守护进程：

　　守护进程作用：辅助主进程的运行，主进程代码运行结束，守护进程就结束

　　主进程创建守护进程：

   　　 1.守护进程会在主进程代码执行结束后就终止

           2.守护进程内无法再开启子进程,否则抛出异常

设置守护进程
from multiprocessing import Process
import time
def work(name):
    print('子进程start')
    time.sleep(3)
    print('子进程end')
def work1(name):
    print('子进程1start')
    time.sleep(3)
    print('子进程1end')

if __name__ == '__main__':
    p = Process(target=work,args=('alex',))
    p1 = Process(target=work1,args=('jing',))
    p.daemon = True#将P设置为守护进程,守护进程会在主进程代码结束后自动回收
    p.start()
    p1.start()
    print('我是主进程')
    # p.terminate() 也是杀死进程，但它的内部可以设置子进程，直接杀死进程，没什么意义
    # 同时p.terminate()也是主进程代码的一部分，因此,主进程的代码结束位置很重要
    p1.terminate()
    time.sleep(1)
    print(p1.is_alive())
    print('主进程代码在这里才是结束')

代码执行结果：

　　p.terminate() 也是杀死进程，但它的内部可以设置子进程，直接杀死进程，子进程僵尸了，没什么意义，同时p.terminate()也是主进程代码的一部分，因此,主进程的代码结束位置很重要

2.同步锁\互斥锁

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

虽然可以用文件共享数据实现进程间通信，但问题是：

   　　　　 1.效率低（共享数据基于文件，而文件是硬盘上的数据）

                  2.需要自己加锁处理。当自己加锁必然导致加锁混乱（据说是加锁过多的情况）

例一：争夺打印机

#多进程竞争终端
#把竞争变得有序，就是由并发执行变成串行，
import os,time,random
from multiprocessing import Process
def work():
    print('我是子进程%s 我现在调用打印机'%(os.getpid()))
    time.sleep(random.randint(1,3))
    print('我是子进程%s 我调用打印机结束'%(os.getpid()))

if __name__ == '__main__':
    p = Process(target=work)
    p1 = Process(target=work)
    p.start()
    # p.join()
    p1.start()
    # p1.join()
    print('我是主进程，主进程结束了')

并行竞争必然导致无序，而无序是不可取的，使竞争变得有序，只能通过串行实现，通过join阻塞，实现串行

以上代码中，实现并行，但是造成调用混乱；通过join（）阻塞变成串行，实现有序调用，但是效率低了

例二：文件模拟数据库，模拟简易的抢票程序

抢票涉及了一个并发查询和购票更改的问题，对于余票的数据进行修改

# 进程之间互换数据
# 理论：找到共有的空间，比如硬盘，但是效率低
#         进程之间内存独立，但是共有同一套硬件，
#
# 抢票,
import time
import random
import json
from multiprocessing import Process,Lock
# 查票 读操作 并发
def search(n):
    dic = json.load(open('db'))
    print('<%s> 查到剩余票数 [%s]'%(n,dic['count']))
#购票 写操作，串行
def get(n):
    dic = json.load(open('db'))#不用编码，序列化的时候，是按照二进制保存的，？？？？
    if dic['count'] >0:
        dic['count'] -= 1
        time.sleep(random.randint(1,3))
        json.dump(dic,open('db','w'))
        print('<%s> 购票成功' % n)
    else:
        print('手慢了')
#加锁方式一     
#加了锁，速度慢了
# def task(n,lock):
#     search(n)
#     lock.acquire()#加锁
#     get(n)
#     lock.release()#加了锁必须释放锁，否则其他的进程不能进来，程序就卡到这里
#加锁方式二
def task(n,lock):
    search(n)
    with lock:
        get(n)

if __name__ == '__main__':
    lock = Lock()
    for i in range(5):
        p = Process(target=task,args=(i,lock,))
        p.start()

3.IPC机制：IPC（Inter-Process Communication，进程间通信）

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

3.1队列（最常用的方式）

主要是针对互斥锁的两个问题：

　　1.效率低（共享数据基于文件，而文件是硬盘上的数据）——>硬盘上速度慢，必须是内存中的

　　2.需要自己加锁处理——>自动处理锁的问题

队列：先进先出，本质是通过（管道+锁）实现的，推荐使用

实现队列的类Queue

 

class Queue(object):
    def __init__(self, maxsize=-1):#maxsize传递了，则是队列中的数量，不传递则无穷大
        self._maxsize = maxsize

    def qsize(self):
        return 0

    def empty(self):
        return False

    def full(self):
        return False

    def put(self, obj, block=True, timeout=None):
        pass

    def put_nowait(self, obj):
        pass

    def get(self, block=True, timeout=None):
        pass

    def get_nowait(self):
        pass

    def close(self):
        pass

    def join_thread(self):
        pass

    def cancel_join_thread(self):
        pass

 q.put方法用以插入数据到队列中，put方法还有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常。
q.get方法可以从队列读取并且删除一个元素。同样，get方法有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出Queue.Empty异常。如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常.
 
q.get_nowait():同q.get(False)
q.put_nowait():同q.put(False)

q.empty():调用此方法时q为空则返回True，该结果不可靠，比如在返回True的过程中，如果队列中又加入了项目。
q.full()：调用此方法时q已满则返回True，该结果不可靠，比如在返回True的过程中，如果队列中的项目被取走。
q.qsize():返回队列中目前项目的正确数量，结果也不可靠，理由同q.empty()和q.full()一样


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

from multiprocessing import Queue

q = Queue(3)

q.put({'a':1})
q.put('alex')
q.put([1,2,3])
#放多了，卡
# q.put(123)
#放不等，满了 抛异常
q.put_nowait('hello')

# print(q.get())
# print(q.get())
# print(q.get())
# 取多了，卡
# print(q.get())
#取不等，没了 抛异常
print(q.get_nowait())

 

3.2管道

http://www.cnblogs.com/linhaifeng/articles/7428874.html#_label6

4.生产者消费者模型

 生产者消费者模型

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

    为什么要使用生产者和消费者模式

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

    什么是生产者消费者模式

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

基于队列实现生产者消费者模型

# 一类功能创造数据 put
# 一类功能基于创造出来的数据进行处理 get
# 队列的方式
import time,random
from multiprocessing import Process,Queue

def producer(name,q):
    for i in range(5):
        time.sleep(random.randint(1,3))
        q.put(i)
        print('厨师<%s>生产了包子[%s]'%(name,i))
    # q.put(None)#生产者发送生产结束标志
def consumer(name,q):
    while True:#消费者一直等待吃，没有结束标志，需要传递一个标志位
        res = q.get()
        if res == None:break
        time.sleep(random.randint(1, 3))
        print('<%s>吃了包子[%s]'%(name,res))

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=producer,args=('egon',q))
    c1 = Process(target=consumer,args=('alex',q))
    p1.start()
    c1.start()
    p1.join()#p1执行完阻塞了，传递了一个None进去
    q.put(None)#主进程发布生产结束的标志

为了在生产者生产结束，发布一个结束标志：

　　#JoinableQueue([maxsize])：这就像是一个Queue对象，但队列允许项目的使用者通知生成者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的。

   #参数介绍：
    maxsize是队列中允许最大项数，省略则无大小限制。    
　 #方法介绍：
    JoinableQueue的实例p除了与Queue对象相同的方法之外还具有：
    q.task_done()：使用者使用此方法发出信号，表示q.get()的返回项目已经被处理。如果调用此方法的次数大于从队列中删除项目的数量，将引发ValueError异常
    q.join():生产者调用此方法进行阻塞，直到队列中所有的项目均被处理。阻塞将持续到队列中的每个项目均调用q.task_done（）方法为止

from multiprocessing import Process, JoinableQueue
import time, random, os

def producer(name, q):
    for i in range(5):
        time.sleep(random.randint(1, 3))
        res = '%s%s' % (name, i)
        q.put(res)
        print('\033[44m%s 生产了 %s\033[0m' % (os.getpid(), res))
    q.join()
#q.join():生产者调用此方法进行阻塞，直到队列中所有的项目均被处理。
# 阻塞将持续到队列中的每个项目均调用q.task_done（）方法为止，即队列中的每个项目均被取走

def consumer(q):
    while True:
        res = q.get()
        time.sleep(random.randint(1, 3))
        print('\033[45m%s 吃 %s\033[0m' % (os.getpid(), res))

        q.task_done()  # 向q.join()发送一次信号,证明一个数据已经被取走了

if __name__ == '__main__':
    q = JoinableQueue()
    # 生产者们:即厨师们
    p1 = Process(target=producer, args=('包子', q))
    p2 = Process(target=producer, args=('骨头', q))
    p3 = Process(target=producer, args=('泔水', q))

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

    # 开始
    p_l = [p1, p2, p3, c1, c2]
    for p in p_l:
        p.start()

    p1.join()
    p2.join()
    p3.join()
    print('主')

    # 主进程等--->p1,p2,p3等---->c1,c2
    # p1,p2,p3结束了,证明c1,c2肯定全都收完了p1,p2,p3发到队列的数据
    # 因而c1,c2也没有存在的价值了,应该随着主进程的结束而结束,所以设置成守护进程

作业：

作业:
    1.编写生产者消费者模型,有多个生产者和多个消费者.(明日默写内容)
    2.模拟12306网站,编写一个支持多用户在线的套接字程序,支持
        - 多用户在线(认证)
        - 认证通过后可以查票,买票(使用互斥锁保证数据安全)
预习:
    进程池
    线程

选做:
    基于进程池实现并发的套接字通信