python-day34--进程补充

一、进程补充：

1，生产者消费者模型：

　　两类角色，一类负责生产数据，另外那类负责数据

　　生产完放到共享空间，另外那类到空间取数据进行处理

　　好处： 生产数据的同时可以进行数据的处理，不用等（并发效果）

　　问题：要有共享空间（1.文件--硬盘，速度慢；2.内存）

　　　　　要有锁

　　队列可以完美解决既是内存空间又自带加锁功能

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

二、共享数据（了解，主要使用队列）

 from multiprocessing import Process,Manager,Lock
 def work(dic,mutex):
     with mutex:
         dic['count']-=1

 if __name__ == '__main__':
     mutex=Lock()
     m=Manager()
     share_dic=m.dict({'count':100})
     l_p=[]
     for i in range(100):
         p=Process(target=work,args=(share_dic,mutex))
         l_p.append(p)
         p.start()
     for i in l_p:
         i.join()
     print(share_dic)

三、进程池（重要知识点）

1.进程池：放进程的池子 -- 控制进程的数量

2. n个cpu 开n个进程 效率最高

3.进程池可以指定大小，如不指定   默认是cpu的个数

4.应用

apply，忘记apply

弊端：apply效率低，串行--主程序要等一个程序运行完才能运行下一个

 from multiprocessing import Pool
 import time,os,random
 def task(n):
     print('%s is running'%os.getpid())
     time.sleep(random.randint(1,3))
     print('%s is done'%os.getpid())
     return n**2

 if __name__ == '__main__':
     p=Pool(4)
     obj_l=[]
     for i in range(1,7):
         obj=p.apply_async(task,args=(i,))    #async提交的是任务 ，不是进程
         obj_l.append(obj)
     p.close()
     p.join()
     print('zhu')
     for obj in obj_l:
         print(obj.get())    #等进程都运行完，一起取结果   --   并发
                         #如果运行完一个进程就取一个结果的话 和apply的效果是一个性质-- 串行

apply_async

#  p.close()      # 禁止往进程池内再添加任务

5. apply_async 的应用：

 from multiprocessing import Pool
 from socket import *
 s=socket(AF_INET,SOCK_STREAM)
 s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
 s.bind(('127.0.0.1',8088))
 s.listen(5)
 def talk(conn):
     while True:
         try:
             cmd=conn.recv(1024)
             if not cmd:break
             conn.send(cmd.upper())
         except Exception:
             break
     conn.close()

 if __name__ == '__main__':
     p=Pool(4)
     while True:
         conn,addr=s.accept()
         p.apply_async(talk,args=(conn,))
     s.close()
                                              #不用考虑主进程等进程池的关闭

多进程并发通信

#也不用考虑返回值接收的问题

6.回调函数（属于主进程）

应用场景：爬虫

 from multiprocessing import Pool
 import requests
 import os
 import time
 def get_page(url):
     print('<%s> is getting [%s]' %(os.getpid(),url))
     response=requests.get(url)
     time.sleep(2)
     print('<%s> is done [%s]' % (os.getpid(), url))
     return {'url':url,'text':response.text}
 def parse_page(res):
     print('<%s> parse [%s]' %(os.getpid(),res['url']))
     with open('db.txt','a') as f:
         parse_res='url:%s size:%s\n' %(res['url'],len(res['text']))
         f.write(parse_res)
 if __name__ == '__main__':
     p=Pool(4)
     urls = [
         'https://www.baidu.com',
         'http://www.openstack.org',
         'https://www.python.org',
         'https://help.github.com/',
         'http://www.sina.com.cn/'
     ]
     for url in urls:
         p.apply_async(get_page,args=(url,),callback=parse_page)
     p.close()
     p.join()
     print('主',os.getpid())

通常进程池的里面的任务是耗时间的，不耗时间（比进程池里的任务耗时短）的任务放到回调函数中

下载完就会调解析功能，节省时间