生产者消费者模型，互斥锁，队列，守护进程

复习
1 进程理论
    什么是进程 ： 一个正在运行的程序
    操作系统的两大功能：
         1 隐藏丑陋的硬件接口，为用户提供良好的接口
         2 管理调用进程，让进程多硬件的竞争变得有序
    多道技术：
         产生背景 ：单核下实现并发
         空间上的复用：内存中同时存放多个程序的数据（硬件层面实现进程内存的隔离）
         时间上的复用：遇到IO阻塞--切，运行时间过长/占用CPU时间过长--切
                        切走之前要保存当前进程的状态
    并发和并行
          并发：看起来是同时运行
          并行：同时运行，只有多核才有并行的概念

2 process模块开进程

3 process内置方法

新内容

守护进程--主进程功能代码结束后，就可以结束了
    主进程创建守护进程
        1--守护进程会在主进程代码执行结束后终止
        2--守护进程内无法再开启子进程，否则抛出异常：
     进程之间是相互独立的，主进程代码运行结束，守护进程随即终止

from multiprocessing import Process
import time
def work(n):
    print("---->start")
    time.sleep(3)
    print("---->end")

if __name__ =="__main__":
    p = Process(target=work,args=("alex",))
    p.daemon = True #--守护进程，deamon属性默认False
    p.start()
    print("主进程")

from multiprocessing import Process
import time

def foo():
    print(123)
    time.sleep(1)
    print("end 123")
def bar():
    print(456)
    time.sleep(3)
    print("end 456")

if __name__ == "__main__":
    p1 = Process(target=foo)
    p2 = Process(target=bar)

    p1.daemon = True    # p1是守护进程，
    p1.start()
    p2.start()
    print("---main---") # 这里是主进场的代码结束，然后守护进场也就结束

打印结果：
    ---main---
    456
    end 456

 

同步锁/互斥锁 lock--锁住一部分(尽量避免加锁)
    把竞争变得有序的核心：由并发变成串行
from multiprocessing import Lock
  开锁lock.acquire()
  解锁lock.release()
  with lock:
      放要加锁的函数

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

def search(n):
    dic = json.load(open("db"))
    time.sleep(1)
    print("<%s> 查到余票 [%s]" %(n,dic["count"]))

def get(n):
    dic = json.load(open("db"))
    if dic["count"] > 0:
        dic["count"] -= 1
        time.sleep(1)
        json.dump(dic,open("db","w"))
        print("<%s> 购票成功" %(n))

def task(n,lock):
    search(n)
    with lock:
        get(n)


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

 

IPC机制--进程之间的通信
    队列和管道
        队列（基于 管道+锁 实现）--先进先出
        Queue模块
        q = Queue(长度)
        q.put(任意数据类型)--放进去，当队列放满时，不报错，会卡在那
        q.get()--拿数据，当对列为空时，不报错，会卡住
        q.put_nowait(任意数据类型)--放进去,当队列放满时，报错
        q.get_nowait()--拿数据，当对列为空时报错

from multiprocessing import Queue

q = Queue(3)

q.put({"a":1})
q.put((1,2,3))
q.put("fdsf")
# q.put_nowait("55555")

print(q.get())
print(q.get())
print(q.get())
# print(q.get_nowait())

 

***** 生产者消费者模型

from multiprocessing import Process,Queue
import time,random

def producer(name,q):
    for i in range(10):
        time.sleep(random.randint(1,3))
        res = "money %s"%i
        q.put(res)
        print("大神 %s 生产了 %s"%(name,res))
def consumer(name,q):
    while True:
        res = q.get()
        if res is None:break
        time.sleep(random.randint(1,3))
        print("%s 拿到了 %s"%(name,res))

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=producer,args=("alex",q))
    c1 = Process(target=consumer,args=("lu",q))

    p1.start()
    c1.start()
    p1.join()

    q.put(None)