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())

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

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

巴特西

python-day34--进程补充

最新文章

热门文章