python进程池停止_python 进程及进程池

一。简介

进程就是一个程序在一个数据集上的一次动态执行过程。 进程一般由程序、数据集、进程控制块三部分组成。我们编写的程序用来描述进程要完成哪些功能以及如何完成；数据集则是程序在执行过程中所需要使用的资源；进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志

二.multiprocessing模块

multiprocessing是python的多进程管理包，和threading.Thread类似。直接从侧面用subprocesses替换线程使用GIL的方式，由于这一点，multiprocessing模块可以让程序员在给定的机器上充分的利用CPU。

在multiprocessing中，通过创建Process对象生成进程，然后调用它的start()方法

from multiprocessing importProcessdeff(name):print('hello', name)if __name__ == '__main__':

p= Process(target=f, args=('bob',))

p.start()

p.join()

进程间的数据共享

进程各自持有一份数据，默认无法共享数据

在使用并发设计的时候最好尽可能的避免共享数据，尤其是在使用多进程的时候。 如果你真有需要 要共享数据， multiprocessing提供了两种方式

内存共享

数据可以用Value或Array存储在一个共享内存地图里，如下:

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

from multiprocessing importProcessfrom multiprocessing importManagerimporttime

li=[]deffoo(i):

li.append(i)print 'say hi',lifor i in range(10):

p= Process(target=foo,args=(i,))

p.start()print 'ending',li

进程间默认无法数据共享

#方法一，Array

from multiprocessing importProcess,Array

temp= Array('i', [11,22,33,44])defFoo(i):

temp[i]= 100+ifor item intemp:print i,'----->',itemfor i in range(2):

p= Process(target=Foo,args=(i,))

p.start()#方法二：manage.dict()共享数据

from multiprocessing importProcess,Manager

manage=Manager()

dic=manage.dict()defFoo(i):

dic[i]= 100+iprintdic.values()for i in range(2):

p= Process(target=Foo,args=(i,))

p.start()

p.join()

当创建进程时(非使用时)，共享数据会被拿到子进程中，当进程中执行完毕后，再赋值给原值

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

from multiprocessing importProcess, Array, RLockdefFoo(lock,temp,i):"""将第0个数加100"""lock.acquire()

temp[0]= 100+ifor item intemp:print i,'----->',item

lock.release()

lock=RLock()

temp= Array('i', [11, 22, 33, 44])for i in range(20):

p= Process(target=Foo,args=(lock,temp,i,))

p.start()

进程锁实例

三.进程池

进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。

进程池中有两个方法：

apply

apply_async

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

from multiprocessing importProcess,PoolimporttimedefFoo(i):

time.sleep(2)return i+100

defBar(arg):printarg

pool= Pool(5)#print pool.apply(Foo,(1,))#print pool.apply_async(func =Foo, args=(1,)).get()

for i in range(10):

pool.apply_async(func=Foo, args=(i,),callback=Bar)print 'end'pool.close()

pool.join()#进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。

from multiprocessing importPool, TimeoutErrorimporttimeimportosdeff(x):return x*xif __name__ == '__main__':#创建4个进程

with Pool(processes=4) as pool:#打印 "[0, 1, 4,..., 81]"

print(pool.map(f, range(10)))#使用任意顺序输出相同的数字，

for i in pool.imap_unordered(f, range(10)):print(i)#异步执行"f(20)"

res = pool.apply_async(f, (20,)) #只运行一个进程

print(res.get(timeout=1)) #输出 "400"

#异步执行 "os.getpid()"

res = pool.apply_async(os.getpid, ()) #只运行一个进程

print(res.get(timeout=1)) #输出进程的 PID

#运行多个异步执行可能会使用多个进程

multiple_results = [pool.apply_async(os.getpid, ()) for i in range(4)]print([res.get(timeout=1) for res inmultiple_results])#是一个进程睡10秒

res = pool.apply_async(time.sleep, (10,))try:print(res.get(timeout=1))exceptTimeoutError:print("发现一个 multiprocessing.TimeoutError异常")print("目前，池中还有其他的工作")#退出with块中已经停止的池

print("Now the pool is closed and no longer available")

官方示例

一个进程池对象可以控制工作进程池的哪些工作可以被提交，它支持超时和回调的异步结果，有一个类似map的实现。

processes ：使用的工作进程的数量，如果processes是None那么使用 os.cpu_count()返回的数量。

initializer： 如果initializer是None，那么每一个工作进程在开始的时候会调用initializer(*initargs)。

maxtasksperchild：工作进程退出之前可以完成的任务数，完成后用一个心的工作进程来替代原进程，来让闲置的资源被释放。maxtasksperchild默认是None，意味着只要Pool存在工作进程就会一直存活。

context: 用在制定工作进程启动时的上下文，一般使用 multiprocessing.Pool() 或者一个context对象的Pool()方法来创建一个池，两种方法都适当的设置了context

注意：Pool对象的方法只可以被创建pool的进程所调用。

New in version 3.2: maxtasksperchild

New in version 3.4: context

进程池的方法

apply(func[, args[, kwds]]) ：使用arg和kwds参数调用func函数，结果返回前会一直阻塞，由于这个原因，apply_async()更适合并发执行，另外，func函数仅被pool中的一个进程运行。

apply_async(func[, args[, kwds[, callback[, error_callback]]]]) ： apply()方法的一个变体，会返回一个结果对象。如果callback被指定，那么callback可以接收一个参数然后被调用，当结果准备好回调时会调用callback，调用失败时，则用error_callback替换callback。 Callbacks应被立即完成，否则处理结果的线程会被阻塞。

close() ： 阻止更多的任务提交到pool，待任务完成后，工作进程会退出。

terminate() ： 不管任务是否完成，立即停止工作进程。在对pool对象进程垃圾回收的时候，会立即调用terminate()。

join() : wait工作线程的退出，在调用join()前，必须调用close() or terminate()。这样是因为被终止的进程需要被父进程调用wait(join等价与wait)，否则进程会成为僵尸进程。

map(func, iterable[, chunksize])¶

map_async(func, iterable[, chunksize[, callback[, error_callback]]])¶

imap(func, iterable[, chunksize])¶

imap_unordered(func, iterable[, chunksize])

starmap(func, iterable[, chunksize])¶

starmap_async(func, iterable[, chunksize[, callback[, error_back]]])