并发编程

1.开启子进程的两种方式

from multiprocessing import Process
import time

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

if __name__ == "__main__":
    # p = Process(target=task,kwargs={'name':'alice'})
    p = Process(target=task,args=('alice',))
    p.start()

    print('主')

from multiprocessing import Process
import time

class MyProcess(Process):
    def __init__(self,name):
        super().__init__()
        self.name = name

    def run(self):
        print('%s is running'%self.name)
        time.sleep(2)
        print("%s is down"%self.name)

if __name__ == "__main__":
    p = MyProcess('子进程1')
    p.start()

    print('主')

2.查看pid
    1.os.getpid()  
    2.os.getppid() 

from multiprocessing import Process
import time
import os

def task(name):
    print('%s is running'%name,os.getpid(),os.getppid())
    time.sleep(2)
    print('%s is down'%name)

if __name__ == "__main__":
    p = Process(target=task,args=('子进程1',))
    p.start()

    print('主',os.getpid(),os.getppid())

3.僵尸进程/孤儿进程
    父进程一直不死，子进程变成了僵尸进程一直占着pid;有害
    孤儿进程，父进程先死了，linux中最大的父进程init进程会回收孤儿进程的pid

4.Process对象的其他属性或方法
    p = Process(target=task,kwargs={'name':'子进程1'})
    p = Process(target=task,name='sub-process',args=('子进程1',))
        0. p.start()     # 只是给os发了一个信号，调用 p.run()  
        1. p.join()      # 等待子进程运行完成
        2. p.pid         # 查看子进程的pid
        3. p.is_alive()  # 查看子进程是否还活着 
        4. p.name        # 查看子进程的name
        5. p.terminate() # 给os发个信号，杀死子进程，信号，需要时间处理
    
    多个子进程p.join()是并发执行，遇到io切 5s 多
    多个子进程p1.start() p1.join() 是串行执行 10s 

from multiprocessing import Process
import os
import time

def task(name,n):
    print('%s is running'%name,os.getpid(),os.getppid())
    time.sleep(n)
    print('%s is down'%name)

if __name__ == "__main__":
    start = time.time()
    p1 = Process(target=task,name='sub-process',args=('子进程1',5))
    p2 = Process(target=task,args=('子进程2',3))
    p3 = Process(target=task,args=('子进程3',2))
    p_l = [p1,p2,p3]  # 并行 5s 多
    for p in p_l:
        p.start()
    print(p1.is_alive())  # True
    p1.terminate()  # 给os 发个信号，杀死子进程，需要时间
    time.sleep(2)
    print(p1.is_alive())  # False
    print(p1.name)
    print(p2.name)
    for p in p_l:
        p.join()

    print(p1.is_alive()) # False
    print(p1.name)
    print(p2.name)
    print(p1.pid)

    # p1.start()   # 串行 10s 多
    # p1.join()
    # p2.start()
    # p2.join()
    # p3.start()
    # p3.join()

    end = time.time()
    print('主',end-start)   # 用时5s多，说明是 并发执行

    # print(p.pid)
    # 这里任然得到了子进程的pid 说明子进程变成了 僵尸进程
    # 主进程结束了，基于它的子进程才会结束，即僵尸进程的pid才会被回收

5.守护进程
    开进程的目的：并发任务，假设任务在主进程死后没意义存在了，就设为守护进程
    守护进程：
        1. p.daemon = True
        2. 主进程结束时，守护进程也结束了
        3. 守护进程一定要在p.start()前设置
        4. 不允许在守护进程内在开子进程，没意义  

from multiprocessing import Process
import time

def task(name):
    print('%s is running'%name)
    time.sleep(2)
    print('%s is down'%name)
    p = Process(target=time.sleep,args=(3,))
    p.start()

if __name__ == "__main__":
    p = Process(target=task,args=('子进程1',))
    p.daemon = True
    p.start()

    print('主')

# 思考下列代码的执行结果有可能有哪些情况？为什么？
from multiprocessing import Process
import time

def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")

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

    p1.daemon=True  # 主进程死后，代码执行完毕，守护进程就死了
    p1.start()
    p2.start()
    print("main-------")  # 只要这里一运行，守护进程就完了
"""
main-------
456
end456
"""

6.互斥锁：
    进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,而共享带来的是竞争，竞争带来的结果就是错乱
    如何控制，就是加锁处理:
        互斥锁的原理，就是把并发改成串行，降低了效率，但保证了数据安全不错乱。保证了多个进程修改一块数据时，一个一个修改，不错乱。

# 并发运行,效率高,但竞争同一打印终端,带来了打印错乱
# 由并发变成了串行,牺牲了运行效率,但避免了竞争
from multiprocessing import Process,Lock
import time
import os

def task(lock):
    lock.acquire()
    print('%s is running'%os.getpid())
    time.sleep(2)
    print('%s is done'%os.getpid())
    lock.release()

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

7.互斥锁的应用：
    模拟抢票 
    加锁处理：购票行为由并发变成了串行，牺牲了运行效率，但保证了数据安全
        with mutex:
            get(name)
        等价于： 
            mutex.acquire()
            mutex.release() 

# 文件db.txt的内容为：{"count":1}
# 注意一定要用双引号，不然json无法识别
import json
import time
from multiprocessing import Process,Lock

def search(name):
    with open('db.txt','r',encoding='utf-8') as f:
        dic =json.load(f)
    time.sleep(1)
    print('33[1;31m%s 查到剩余票数 %s33[0m'%(name,dic['count']))

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

def task(name,mutex):
    search(name)
    # mutex.acquire()
    # get(name)
    # mutex.release()
    with mutex:
        get(name)

if __name__ == "__main__":
    mutex = Lock()
    for i in range(4):
        p = Process(target=task,args=('用户%s'%i,mutex))
        p.start()
"""
用户0 查到剩余票数 2
用户1 查到剩余票数 2
用户2 查到剩余票数 2
用户3 查到剩余票数 2
用户0 购票成功
用户1 购票成功
"""

8.互斥锁与join的区别：
    使用join可以将并发变成串行，互斥锁的原理也是将并发变成串行
    区别：
        1.join是将一个任务整体串行
        2.互斥锁的好处则是可以将一个任务中的某一段代码串行

import json
import time
from multiprocessing import Process,Lock

def search(name):
    with open('db.txt','r',encoding='utf-8') as f:
        dic =json.load(f)
    time.sleep(1)
    print('33[1;31m%s 查到剩余票数 %s33[0m'%(name,dic['count']))

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

def task(name):
    search(name)
    get(name)

if __name__ == "__main__":
    for i in range(4):
        p = Process(target=task,args=('用户%s'%i,))
        p.start()
        p.join()
"""
用户0 查到剩余票数 1
用户0 购票成功
用户1 查到剩余票数 0
用户2 查到剩余票数 0
用户3 查到剩余票数 0
"""

9.互斥锁总结：
    加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行地修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。
    虽然可以用文件共享数据实现进程间通信，但问题是：
        1.效率低（共享数据基于文件，而文件是硬盘上的数据）
        2.需要自己加锁处理
    因此我们最好找寻一种解决方案能够兼顾：
        1.效率高
        2.帮我们处理好锁的问题
    这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。
        队列和管道都是将数据存放于内存中，而队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，因而队列才是进程间通信（IPC）的最佳选择。
    队列作用：
       多个进程之间通信使用的，一个进程将数据放到队列里面，另外一个进程从队列里面取走数据，干的是进程之间通信的活

10.队列：
    进程彼此之间是相互隔离的，要实现进程间通信（IPC）,multiprocessing模块支持两种形式：队列 管道
    队列 = 管道 + 锁 
    q = Queue(3)  # 省略无大小限制 maxsize
    注： 
        1.队列内存放的是消息而非大数据
        2.队列占用的是内存空间，而maxsize即便无大小限制也受限于内存大小 

11.队列的使用： 先进先出  
    q = Queue(3)
    q.put(2)
    q.get()
    q.full()
    q.empty()
    q.put_nowait(2)  # 无阻塞，当队列满时，直接抛出异常 queue.Full
    q.get_nowait()   # 无阻塞，当队列空时，直接抛出异常 queue.Empty 

from multiprocessing import Process,Lock,Queue

q = Queue(3)
q.put(2)
q.put([1,2,3])
# q.put_nowait()
q.put({'name':'alice'})
# q.put_nowait(1)
# q.put(1)
print(q.full())
# q.put('aa')  # 满了 再放就阻塞了

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

# print(q.get()) # 空了 在取就阻塞了

12.生产者消费者模型：
    生产者：生产数据的任务
    消费者：处理数据的任务 
    
    生产者与消费者模型：
        生产者与消费者之间引入一个容器(队列)：  
        生产者《---》队列《---》消费者
            生产者：一个进程
            消费者：一个进程
            进程间通信(IPC)：队列 Queue 
        
    好处：程序解开耦合，生产者与消费者不直接通信,平衡了生产者与消费者的速度差  
    注：
        q.put(None)  # 有几个消费者，就发送几个结束信号 None 相当low 

import time,os
from multiprocessing import Process, Queue

def producter(q):
    for i in range(4):
        res = '包子%s'%i
        time.sleep(0.5)
        print('生产者生产了 %s'%res)

        q.put(res)

def consumer(q):
    while True:
        res = q.get()
        if not res:break
        time.sleep(1)
        print('%s消费者吃了%s'%(os.getpid(),res))

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=producter,args=(q,))
    c1 = Process(target=consumer,args=(q,))
    c2 = Process(target=consumer, args=(q,))
    p1.start()
    c1.start()
    c2.start()

    p1.join()
    q.put(None)  # 有几个消费者，就要放几个None
    q.put(None)  # 有几个消费者，就发送几个结束信号 None 相当low

    print('主')
"""
生产者生产了 包子0
生产者生产了 包子1
生产者生产了 包子2
20280消费者吃了包子0
生产者生产了 包子3
11920消费者吃了包子1
主
20280消费者吃了包子2
11920消费者吃了包子3
"""

13.JoinableQueue:
    基于JoinableQueue实现生产者消费者模型:
        q = JoinableQueue(size)  # size 省略则大小无限制
        生产者：q.join() 
        消费者：q.task_done()   
        并且：消费者设为守护进程  

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

def producter(q):
    for i in range(4):
        res = '包子%s'%i
        time.sleep(0.5)
        print('%s生产者生产了 %s'%(os.getpid(),res))

        q.put(res)
    q.join()  # 等到消费者把自己放入队列中的所有的数据都取走之后，生产者才结束

def consumer(q):
    while True:
        res = q.get()
        time.sleep(1)
        print('%s消费者吃了%s'%(os.getpid(),res))
        q.task_done()   # 发送信号给q.join()，说明已经从队列中取走一个数据并处理完毕了

if __name__ == '__main__':
    # 容器
    q = JoinableQueue()
    # 生产者
    p1 = Process(target=producter,args=(q,))
    p2 = Process(target=producter, args=(q,))
    # 消费者
    c1 = Process(target=consumer,args=(q,))
    c2 = Process(target=consumer, args=(q,))

    p1.start()
    p2.start()

    c1.daemon = True  # 必须设为守护进程
    c2.daemon = True

    c1.start()
    c2.start()

    p1.join()
    p2.join()

    print('主')
"""
    1、主进程等生产者p1、p2结束
    2、而p1、p2是在消费者把所有数据都取干净之后才会结束
    3、所以一旦p1、p2结束了，证明消费者也没必要存在了，应该随着主进程一块死掉，因而需要将消费者设置成守护进程
"""
"""
18712生产者生产了 包子0
19100生产者生产了 包子0
18712生产者生产了 包子1
19100生产者生产了 包子1
19636消费者吃了包子0
18712生产者生产了 包子2
18084消费者吃了包子0
19100生产者生产了 包子2
18712生产者生产了 包子3
19100生产者生产了 包子3
19636消费者吃了包子1
18084消费者吃了包子1
19636消费者吃了包子2
18084消费者吃了包子2
19636消费者吃了包子3
18084消费者吃了包子3
主
"""

14.生产者消费者模型总结： 
    1.程序中有两类角色：
        一类负责生产数据（生产者）
        二类负责处理数据（消费者）
    2.引入生产者消费者模型为了解决的问题是：
        1.平衡生产者与消费者之间的速度差
        2.程序解开耦合
    3.如何实现生产者消费者模型：
        生产者《---》队列《---》消费者 

 

　Python多进程通信Queue、Pipe、Value、Array实例

　　queue和pipe用来在进程间传递消息;
　　Value + Array 是python中共享内存映射文件的方法;速度比较快.

 　 http://www.jb51.net/article/57666.htm

　进程间共享数据  multiprocessing.Manager

　  http://www.jb51.net/article/57663.htm