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的效果是一个性质-- 串行

     #  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
' %(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())

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

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