铁乐学python_Day40_进程池

进程之间的数据共享

基于消息传递的并发编程是大势所趋,

即便是使用线程,推荐做法也是将程序设计为大量独立的线程集合,通过消息队列交换数据。

这样极大地减少了对使用锁和其他同步手段的需求,还可以扩展到分布式系统中。

但进程间应该尽量避免通信,即便需要通信,也应该选择进程安全的工具来避免加锁带来的问题。

以后我们会尝试使用数据库来解决现在进程之间的数据共享问题。

进程间数据是独立的,可以借助于队列或管道实现通信,二者都是基于消息传递的。

虽然进程间数据独立,但可以通过Manager实现数据共享,事实上Manager的功能远不止于此。

A manager object returned by Manager() controls a server process which holds Python objects and allows other processes to manipulate them using proxies.

A manager returned by Manager() will support types list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array.

Manager支持的类型也很多。

例:
from multiprocessing import Manager,Process,Lock
def work(d,lock):
# with lock 就相当于一组 lock.acquire()  lock.release()
# 上下文管理 :必须有一个开始动作 和 一个结束动作的时候
    with lock: #不加锁而操作共享的数据,肯定会出现数据错乱
        d[‘count‘]-=1

if __name__ == ‘__main__‘:
    lock=Lock()
    with Manager() as m:
        dic=m.dict({‘count‘:100})
        p_l=[]
        for i in range(98):
            p=Process(target=work, args=(dic, lock))
            p_l.append(p)
            p.start()
        for p in p_l:
            p.join()
        print(dic)

进程池和multiprocess.Pool模块

进程池

为什么要有进程池?进程池的概念。

在程序实际处理问题过程中,忙时会有成千上万的任务需要被执行,闲时可能只有零星任务。

那么在成千上万个任务需要被执行的时候,我们就需要去创建成千上万个进程么?

首先,创建进程需要消耗时间,销毁进程也需要消耗时间。

第二即便开启了成千上万的进程,操作系统也不能让他们同时执行,这样反而会影响程序的效率。

因此我们不能无限制的根据任务开启或者结束进程。

那么我们要怎么做呢?

在这里,要给大家介绍一个进程池的概念,定义一个池子,在里面放上固定数量的进程,

有需求来了,就拿一个池中的进程来处理任务,等到处理完毕,进程并不关闭,

而是将进程再放回进程池中继续等待任务。

如果有很多任务需要执行,池中的进程数量不够,

任务就要等待之前的进程执行任务完毕归来,拿到空闲进程才能继续执行。

也就是说,池中进程的数量是固定的,那么同一时间最多有固定数量的进程在运行。

这样不会增加操作系统的调度难度,还节省了开闭进程的时间,也一定程度上能够实现并发效果。

multiprocess.Pool模块

概念介绍

Pool([numprocess [,initializer [, initargs]]]):创建进程池

参数介绍:

1 numprocess:要创建的进程数,如果省略,将默认使用cpu_count()的值

2 initializer:是每个工作进程启动时要执行的可调用对象,默认为None

3 initargs:是要传给initializer的参数组

主要方法:
p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。
‘‘‘需要强调的是:此操作并不会在所有池工作进程中并执行func函数。
如果要通过不同参数并发地执行func函数,必须从不同线程调用p.apply()函数或者使用p.apply_async()‘‘‘

p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。
‘‘‘此方法的结果是AsyncResult类的实例,callback是可调用对象,接收输入参数。当func的结果变为可用时,将理解传递给callback。callback禁止执行任何阻塞操作,否则将接收其他异步操作中的结果。‘‘‘

p.close():关闭进程池,防止进一步操作。如果所有操作持续挂起,它们将在工作进程终止前完成。

P.jion():等待所有工作进程退出。此方法只能在close()或teminate()之后调用。

方法apply_async()和map_async()的返回值是AsyncResul的实例obj。
实例具有以下方法
obj.get():返回结果,如果有必要则等待结果到达。
timeout是可选的。如果在指定时间内还没有到达,将引发异常。
如果远程操作中引发了异常,它将在调用此方法时再次被引发。
obj.ready():如果调用完成,返回True。
obj.successful():如果调用完成且没有引发异常,返回True,如果在结果就绪之前调用此方法,引发异常。
obj.wait([timeout]):等待结果变为可用。
obj.terminate():立即终止所有工作进程,同时不执行任何清理或结束任何挂起工作。
如果p被垃圾回收,将自动调用此函数。

例:进程池的同步调用
import os,time
from multiprocessing import Pool

def work(n):
    print(‘%s run‘ %os.getpid())
    time.sleep(2)
    return n**2

if __name__ == ‘__main__‘:
    p=Pool(3) #进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务
    res_l=[]
    for i in range(10):
        res_l.append(p.apply(work,args=(i,)))
      # 同步调用,直到本次任务执行完毕拿到return,
      # 等待任务work执行的过程中可能有阻塞也可能没有阻塞
       # 但不管该任务是否存在阻塞,同步调用都会在原地等着
    print(res_l)

972 run
8036 run
892 run
972 run
8036 run
892 run
972 run
8036 run
892 run
972 run
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

例:进程池的异步调用
import os
import time
import random
from multiprocessing import Pool

def work(n):
    print(‘%s run‘ %os.getpid())
    time.sleep(random.random())
    return n**2

if __name__ == ‘__main__‘:
    p=Pool(3) #进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务
    res_l=[]
    for i in range(10):
        res = p.apply_async(work, args=(i,))
        # 异步运行,根据进程池中有的进程数,每次最多3个子进程在异步执行
        # 返回结果之后,将结果放入列表,归还进程,之后再执行新的任务
        # 需要注意的是,进程池中的三个进程不会同时开启或者同时结束
        # 而是执行完一个就释放一个进程,这个进程就去接收新的任务。
        res_l.append(res)

    # 异步apply_async用法:如果使用异步提交的任务,主进程需要使用jion,
    # 等待进程池内任务都处理完,然后可以用get收集结果
    # 否则,主进程结束,进程池可能还没来得及执行,也就跟着一起结束了
    p.close()
    p.join()
    for res in res_l:
        print(res.get())
    # 使用get来获取apply_aync的结果,如果是apply,则没有get方法,
    # 因为apply是同步执行,立刻获取结果,也根本无需get。

例:server:进程池版socket并发聊天

#!/usr/bin/env python
# _*_ coding: utf-8 _*_

# Pool内的进程数默认是cpu核数,假设为4(查看方法os.cpu_count())
# 开启6个客户端,会发现2个客户端处于等待状态
# 在每个进程内查看pid,会发现pid使用为4个,即多个客户端公用4个进程
from socket import *
from multiprocessing import Pool
import os

server = socket(AF_INET, SOCK_STREAM)
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server.bind((‘127.0.0.1‘, 9527))
server.listen(5)

def talk(conn):
    print(‘进程pid: %s‘ % os.getpid())
    while True:
        try:
            msg = conn.recv(1024)
            if not msg: break
            conn.send(msg.upper())
        except Exception:
            break

if __name__ == ‘__main__‘:
    p = Pool(4)
    while True:
        conn, *_ = server.accept()
        p.apply_async(talk, args=(conn,))

client端
#!/usr/bin/env python
# _*_ coding: utf-8 _*_

from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect((‘127.0.0.1‘, 9527))

while True:
    msg=input(‘>>: ‘).strip()
    if not msg:continue

    client.send(msg.encode(‘utf-8‘))
    msg=client.recv(1024)
    print(msg.decode(‘utf-8‘))

效果:
进程pid: 7980
进程pid: 6252
进程pid: 7156
进程pid: 7564
进程pid: 7980

同时只能开启4个进程,开第五个进程的时候会被阻塞,直到手动关掉前四个中的其中一个,第五个才能进到池子里运行。
并发开启多个客户端,服务端同一时间只有4个不同的pid,只能结束一个客户端,另外一个客户端才会进来.

回调函数  callback=
需要回调函数的场景:进程池中任何一个任务一旦处理完了,就立即告知主进程:我好了,你可以处理我的结果了。主进程则调用一个函数去处理该结果,该函数即回调函数

我们可以把耗时间(阻塞)的任务放到进程池中,然后指定回调函数(主进程负责执行),这样主进程在执行回调函数时就省去了I/O的过程,直接拿到的是任务的结果。

常用于爬虫场景。

例:使用多进程请求多个url来减少网络等待浪费的时间
#!/usr/bin/env python
# _*_ coding: utf-8 _*_

from multiprocessing import Pool
import requests
import os

def get_page(url):
    print(‘<进程%s> get %s‘ % (os.getpid(), url))
    respone = requests.get(url)
    if respone.status_code == 200:
        return {‘url‘: url, ‘text‘: respone.text}

def pasrse_page(res):
    print(‘<进程%s> parse %s‘ % (os.getpid(), res[‘url‘]))
    parse_res = ‘url:<%s> size:[%s]\n‘ % (res[‘url‘], len(res[‘text‘]))
    with open(‘db.txt‘, ‘a‘) as f:
        f.write(parse_res)

if __name__ == ‘__main__‘:
    urls = [
        ‘https://www.baidu.com‘,
        ‘https://www.python.org‘,
        ‘https://www.openstack.org‘,
        ‘https://help.github.com/‘,
        ‘http://www.sina.com.cn/‘
    ]

    p = Pool(3)
    res_l = []
    for url in urls:
        res = p.apply_async(get_page, args=(url,), callback=pasrse_page)
        res_l.append(res)

    p.close()
    p.join()
    print([res.get() for res in res_l])
    # 拿到的是get_page的结果,其实完全没必要拿该结果,该结果已经传给回调函数处理了

爬虫实例:
#!/usr/bin/env python
# _*_ coding: utf-8 _*_
import re
from urllib.request import urlopen
from multiprocessing import Pool

def get_page(url, pattern):
    response = urlopen(url).read().decode(‘utf-8‘)
    return pattern, response

def parse_page(info):
    pattern, page_content = info
    res = re.findall(pattern, page_content)
    for item in res:
        dic = {
            ‘index‘: item[0].strip(),
            ‘title‘: item[1].strip(),
            ‘actor‘: item[2].strip(),
            ‘time‘: item[3].strip(),
        }
        print(dic)

if __name__ == ‘__main__‘:
    regex = r‘<dd>.*?<.*?class="board-index.*?>(\d+)</i>.*?title="(.*?)".*?class="movie-item-info".*?<p class="star">(.*?)</p>.*?<p class="releasetime">(.*?)</p>‘
    pattern1 = re.compile(regex, re.S)

    url_dic = {
        ‘http://maoyan.com/board/7‘: pattern1,
    }

    p = Pool()
    res_l = []
    for url, pattern in url_dic.items():
        res = p.apply_async(get_page, args=(url, pattern), callback=parse_page)
        res_l.append(res)

    for i in res_l:
        i.get()

效果:
{‘index‘: ‘1‘, ‘actor‘: ‘主演:泰尔·谢里丹,奥利维亚·库克,本·门德尔森‘, ‘time‘: ‘上映时间:2018-03-30‘, ‘title‘: ‘头号玩家‘}
{‘index‘: ‘2‘, ‘actor‘: ‘主演:道恩·强森,娜奥米·哈里斯,杰弗里·迪恩·摩根‘, ‘time‘: ‘上映时间:2018-04-13‘, ‘title‘: ‘狂暴巨兽‘}
{‘index‘: ‘3‘, ‘actor‘: ‘主演:帕拉巴斯,拉纳·达格巴帝,安努舒卡·谢蒂‘, ‘time‘: ‘上映时间:2018-05-04‘, ‘title‘: ‘巴霍巴利王2:终结‘}
{‘index‘: ‘4‘, ‘actor‘: ‘主演:小罗伯特·唐尼,克里斯·海姆斯沃斯,马克·鲁法洛‘, ‘time‘: ‘上映时间:2018-05-11‘, ‘title‘: ‘复仇者联盟3:无限战争‘}
{‘index‘: ‘5‘, ‘actor‘: ‘主演:奧古斯特·迪赫,史特凡·柯纳斯克,薇姬·克里普斯‘, ‘time‘: ‘上映时间:2018-05-05‘, ‘title‘: ‘青年马克思‘}
{‘index‘: ‘6‘, ‘actor‘: ‘主演:闫妮,邹元清,吴若甫‘, ‘time‘: ‘上映时间:2018-05-11‘, ‘title‘: ‘我是你妈‘}
{‘index‘: ‘7‘, ‘actor‘: ‘主演:凯特·玛拉,汤姆·费尔顿,布莱德利·惠特福德‘, ‘time‘: ‘上映时间:2018-05-11‘, ‘title‘: ‘战犬瑞克斯‘}
{‘index‘: ‘8‘, ‘actor‘: ‘主演:郭京飞,迪丽热巴,大鹏‘, ‘time‘: ‘上映时间:2018-04-20‘, ‘title‘: ‘21克拉‘}
{‘index‘: ‘9‘, ‘actor‘: ‘主演:杰森·格里菲,劳里·海梅斯,迪·布拉雷·贝克尔‘, ‘time‘: ‘上映时间:2018-04-05‘, ‘title‘: ‘冰雪女王3:火与冰‘}
{‘index‘: ‘10‘, ‘actor‘: ‘主演:井柏然,周冬雨,田壮壮‘, ‘time‘: ‘上映时间:2018-04-28‘, ‘title‘: ‘后来的我们‘}

如果在主进程中等待进程池中所有任务都执行完毕后,再统一处理结果,则无需回调函数。

例:
#!/usr/bin/env python
# _*_ coding: utf-8 _*_

from multiprocessing import Pool
import time

def work(n):
    time.sleep(1)
    return n ** 2

if __name__ == ‘__main__‘:
    p = Pool()

    res_l = []
    for i in range(10):
        res = p.apply_async(work, args=(i,))
        res_l.append(res)

    p.close()
    p.join()  # 等待进程池中所有进程执行完毕

    nums = []
    for res in res_l:
        nums.append(res.get())  # 拿到所有结果
    print(nums)  # 主进程拿到所有的处理结果,可以在主进程中进行统一进行处理

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

end

原文地址:https://www.cnblogs.com/tielemao/p/9043008.html

时间: 2024-10-07 19:13:17

铁乐学python_Day40_进程池的相关文章

铁乐学Python_Day34_Socket模块2和黏包现象

铁乐学Python_Day34_Socket模块2和黏包现象 套接字 套接字是计算机网络数据结构,它体现了C/S结构中"通信端点"的概念. 在任何类型的通信开始之前,网络应用程序必須创建套接字. 可以将它们比作成电话插孔,没有它将无法进行通信. 套接字最初是为同一主机上的应用程序所创建,使得主机上运行的一个程序(又名一个进程)与另一个运行的程序进行通信. 这就是所谓的进程间通信(Inter Process Communication, IPC). 有两种类型的套接字:基于文件的和面向网

铁乐学python_Day39_多进程和multiprocess模块2

锁 -- multiprocess.Lock (进程同步) 之前我们千方百计实现了程序的异步,让多个任务可以同时在几个进程中并发处理, 但是它们之间的运行没有顺序,一旦开启也不受我们控制. 尽管并发编程能让我们更加充分的利用IO资源,但是也会带来新的问题. 当多个进程使用同一份数据资源的时候,就会引发数据安全或顺序混乱问题. 遇到数据.安全比速度重要的场景,我们就需要将进程变回受同步控制. 例: #!/usr/bin/env python # _*_ coding: utf-8 _*_ impo

内存池、进程池、线程池

首先介绍一个概念"池化技术 ".池化技术 一言以蔽之就是:提前保存大量的资源,以备不时之需以及重复使用. 池化技术应用广泛,如内存池,线程池,连接池等等.内存池相关的内容,建议看看Apache.Nginx等开源web服务器的内存池实现. 起因:由于在实际应用当中,分配内存.创建进程.线程都会设计到一些系统调用,系统调用需要导致程序从用户态切换到内核态,是非常耗时的操作.           因此,当程序中需要频繁的进行内存申请释放,进程.线程创建销毁等操作时,通常会使用内存池.进程池.

Python 3 进程池与回调函数

Python 3 进程池与回调函数 一.进程池 在利用Python进行系统管理的时候,特别是同时操作多个文件目录,或者远程控制多台主机,并行操作可以节约大量的时间.多进程是实现并发的手段之一,需要注意的问题是: 很明显需要并发执行的任务通常要远大于核数 一个操作系统不可能无限开启进程,通常有几个核就开几个进程 进程开启过多,效率反而会下降(开启进程是需要占用系统资源的,而且开启多余核数目的进程也无法做到并行) 例如当被操作对象数目不大时,可以直接利用multiprocessing中的Proces

Windows2008操作系统 IIS7 IIS7.5 进程池经常死最终解决方案

作为一个服务器维护人员,经常遇到不可解决的问题,这问题一直存在,一直困扰我多时,经常凌晨1-2点起床,就为了重启一下进程池 错误应用程序名称: w3wp.exe,版本: 7.5.7600.16385,时间戳: 0x4a5bd0eb错误模块名称: ntdll.dll,版本: 6.1.7600.16385,时间戳: 0x4a5be02b异常代码: 0xc0000374错误偏移量: 0x00000000000c6cd2错误进程 ID: 0xb54c错误应用程序启动时间: 0x01d0c0d94f915

python进程池剖析(一)

python中两个常用来处理进程的模块分别是subprocess和multiprocessing,其中subprocess通常用于执行外部程序,比如一些第三方应用程序,而不是Python程序.如果需要实现调用外部程序的功能,python的psutil模块是更好的选择,它不仅支持subprocess提供的功能,而且还能对当前主机或者启动的外部程序进行监控,比如获取网络.cpu.内存等信息使用情况,在做一些自动化运维工作时支持的更加全面.multiprocessing是python的多进程模块,主要

python进程池剖析(二)

之前文章中介绍了python中multiprocessing模块中自带的进程池Pool,并对进程池中的数据结构和各个线程之间的合作关系进行了简单分析,这节来看下客户端如何对向进程池分配任务,并获取结果的. 我们知道,当进程池中任务队列非空时,才会触发worker进程去工作,那么如何向进程池中的任务队列中添加任务呢,进程池类有两组关键方法来创建任务,分别是apply/apply_async和map/map_async,实际上进程池类的apply和map方法与python内建的两个同名方法类似,ap

使用进程池规避Python的GIL限制

操作系统 : CentOS7.3.1611_x64 python版本:2.7.5 问题描述 Python的GIL会对CPU密集型的程序产生影响,如果完全使用Python来编程,怎么避开GIL的限制呢? 解决方案 在多线程中使用进程池来规避GIL的限制.具体如下: 1.使用multiprocessing模块来创建进程池: 2.将计算任务分配给不同的线程: 3.在任务线程中把任务提交给之前创建的进程池: 每当有线程要执行cpu密集型任务时,就把该任务提交到进程池中,然后进程池会将任务交给运行在另一个

24、进程池

什么是进程池呢? 当一个主进程执行过程中需要创建子进程来完成多个任务时候,那么如果运用fork来进行创建然后再回收, 在创建在回收,降低主进程性能.所以事先创建进程池. 当需要创建的子进程数量不多时,可以直接利用multiprocessing中的Process动态成生多个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool方法 from multiprocessing import Poolimport os def wo