python学习之路-进程-day09

大纲：
1.为什么需要多进程
2.多进程创建
3.利用进程实现管道通讯
4.多进程信息共享
5.进程锁
6.进程池
7.队列
一.Python既然有了多线程，为什么还要使用多进程？
Python的多线程（每个cpu在同一时间只能执行一个线程，Python的多线程只是上下文的切换，因为cpu的速度非常的快，所以我们并不能感觉到它的切换，，也就是python的多线程并不是多任务的并行）
python为了保证数据的安全（确保同一份数据在同一时间只能被同一个线程修改），所以每次执行代码之前必须要获取全局解释器锁GIL（global interpreter lock）
因为GIL的存在多以一个进程内同一时间只能同时执行一个线程，多核上CPU的效率大大降低了。
python下的多线程对CPU密集型代码效率低，因此我们引入了多进程（每个进程有各自独立的GIL，互不干扰，这样就可以真正意义上的并行执行）。python的多线程对IO密集型代码(文件处理、网络爬虫等)比较有优势。
二.多进程创建

import multiprocessing
from multiprocessing import process
import time,os
def run(name):
    time.sleep(2)
    print("%s in run id %s"%(name,os.getpid()))

if __name__=="__main__":
    for i in range(3):
      p=multiprocessing.Process(target=run,args=("%s"%i,))
      p.start()
#结果：0 in run id 12188
#      1 in run id 12700
#      2 in run id 13608

三.利用进程实现管道通讯

#import multiprocessing
from multiprocessing import Process,Pipe#pipe是管道
def run(conn):
   conn.send("hello")#子端管道发送消息
   print("from parent information:",conn.recv())#子端管道接收消息
   conn.close()
if __name__=="__main__":
    parent_pipe,child_pipe=Pipe()#管道只要创建就会有两个返回值，就是管道的两端
    p=Process(target=run,args=(child_pipe,))#创建子端管道的进程
    p.start()#启动子端管道的进程
    print( parent_pipe.recv())#父端管道接收
    parent_pipe.send("how are you")#父端管道发送消息
    p.join()#阻塞主进程，可以等待子进程结束后再继续往下运行，通常用于进程间的同步
    print("process over...")
#执行结果：hello
#          from parent information: how are you
#          process over..
#去掉join后的执行结果hello
#                    process over...
#                    from parent information: how are you

四.实现多个进程间的信息共享，共同操作同一份数据（列表，字典，锁，变量，信号，事件。。。）–Manager()

import  multiprocessing
from multiprocessing import managers,process
import os
def run(d,l):
    d[1]="hello"
    d[2]="jack"
    l.append(os.getpid())
    print(l)
if __name__=="__main__":
        man=multiprocessing.Manager()
        d=man.dict()#生成一个字典可以在多进程时用于信息的传递
        l=man.list()#生成一个列表
        obj=[]#一个空列表
        for i in range(9):
            p=multiprocessing.Process(target=run,args=(d,l))#创建d,l进程
            p.start()
            obj.append(p)
        for t in obj:
            t.join()
        print(d)
        print(l)
# [6780]
# [6780, 6744]
# [6780, 6744, 9120]
# [6780, 6744, 9120, 15304]
# [6780, 6744, 9120, 15304, 14320]
# [6780, 6744, 9120, 15304, 14320, 3596]
# [6780, 6744, 9120, 15304, 14320, 3596, 17252]
# [6780, 6744, 9120, 15304, 14320, 3596, 17252, 16988]
# [6780, 6744, 9120, 15304, 14320, 3596, 17252, 16988, 17212]
# {1: 'hello', 2: 'jack'}
# [6780, 6744, 9120, 15304, 14320, 3596, 17252, 16988, 17212]

五.进程锁
进程的数据明明是独立的为什么还要加锁？因为输出屏幕的共享，为了防止控制输出变乱

import multiprocessing
from multiprocessing import Process, Lock
def f(l,i):
    l.acquire()
    print("hello world",i)
    l.release()

if __name__=="__main__":
    lock=Lock()
    for num in range(10):
        Process(target=f,args=(lock,num)).start()

六.进程池（pool）
作用：限制同一时间在cpu上运行的进程的个数
如果要启动大量的子进程，可以用进程池的方式批量创建子进程
运行这段代码的时候我的的CPU占用率高达99%,造成死机

import time
from multiprocessing import Process, Pool
def foo(num):
    time.sleep(2)
    return num*2
#__name__ 是当前模块名，当模块被直接运行时模块名为 __main__ 。这句话的意思就是，
# 当模块被直接运行时，以下代码块将被运行，当模块是被导入时，代码块不被运行
pool=Pool(5)#在进程池中放入5个进程，其余均处于挂起状态
for i in range(5):
    pool.apply_async(func=foo,args=("t-%s"%i,))
         #apply----同步，串行    apply_async------异步，并行
print("working---------")
pool.close()
pool.join()#必须先关闭再join！！！！
print("process end")
#进程池中进程执行完毕后再关闭，如果注释，程序直接关闭

七.队列（Queue）
1.队列的操作方法

import queue
#1.创建一个队列
q = queue.Queue(maxsize = 10)#maxsize来设定队列长度。如果maxsize小于1就表示队列长度无限
#2.在队尾插入一个数
#put(self, item, block=True, timeout=None) item为插入的值，
q.put()
#3.将一个值从队列里面取出来
q.get()
q.qsize() #返回队列的大小
q.empty() #如果队列为空，返回True,反之False
q.full() #如果队列满了，返回True,反之False
q.full #与 maxsize 大小对应
q.get([block[, timeout]]) #获取队列，timeout等待时间
q.get_nowait() #相当q.get(False)
q.put(item) #写入队列，timeout等待时间
q.put_nowait(item) #相当q.put(item, False)
q.task_done() #在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号
q.join() #实际上意味着等到队列为空，再执行别的操作

2.提供了一个适用于多线程编程的先进先出的数据结构，即队列，用来在生产者和消费者线程之间的信息传递。
FIFO队列–先进先出

import queue
q=queue.Queue()
for i in range(10):
    q.put(i)
while q is not None:
    print(q.get())#输出0-9

LIFO队列–后进先出
q=queue.LifoQueue()
优先级队列
q=queue.PriorityQueue()
3.队列实例分析，生产者消费者模型

import queue,time,threading
#实现一个线程不停的生产包子到队列里面
#另一个线程上的消费者不停的取出队列里面的包子
q=queue.Queue(maxsize=10)
def product(name):
    count=1
    while True:
        q.put("包子%s"%count)
        print("生产了包子num:",count)
        count+=1
def custom(name):
    while True:
        print("%s买了%s个包子..."%(name,q.get()))
        time.sleep(0.1)
p=threading.Thread(target=product,args=("jack",))
p.start()
c=threading.Thread(target=custom,args=("rose",))
c.start()