python进程池详解

最新推荐文章于 2024-08-05 19:57:48 发布

weixin_34221276

最新推荐文章于 2024-08-05 19:57:48 发布

阅读量272

点赞数

文章标签： python c/c++ 操作系统

原文链接：https://my.oschina.net/u/3572879/blog/1556878

版权

2019独角兽企业重金招聘Python工程师标准>>>

python进程池multiprocessing.Pool和线程池multiprocessing.dummy.Pool实例

1，Python的multiprocessing 实现多cpu 多进程

为啥用multiprocessing？

*现在cpu都多核了，写大型程序你还在用单线程的传统写法？很不fashion而且效率很低，你out了。

*那用multi-threading不就结了？C语言可以，编译完执行没问题。但是python这种解释型的语言用多线程就不行了， python的multithreading效率并不高。据说是受制于GIL (global interpreter lock) 的锁机制, 该锁只能工作于单个cpu core。这样别的cpu core干着急也帮不上忙。

*那怎么办呢？自己fork一堆子进程，然后管理呗？呵呵，DIY？这不是重新造轮子吗。

*亲，用python现成的multiprocessing库吧。支持多个cpu core，简直就是为了多核cpu打造的， python 2.6之后都支持。

不用说了，直接上干货

*sample 1，创建process, target=f 函数名， args传递参数

# encoding: utf8
# @Time    : 2017/10/26 20:54
# @Author  : Ycs
# @Site    : 
# @File    : mymultiprocessing.py
# @Desc    : Python的multiprocessing 实现多cpu 多进程, python进程池multiprocessing.Pool和线程池multiprocessing.dummy.Pool实例

from multiprocessing import Process,Queue,Pipe,Pool
import time


def f(name):
    print('hello:', name)


if __name__ == '__main__':
    #创建process, target=f 函数名， args传递参数
    p=Process(target=f,args=('bbb',))
    p.start()
    p.join()

    #支持队列

def ff(q):
    q.put([42,None,'hello'])

if __name__ == '__main__':
    q=Queue()
    p=Process(target=ff,args=(q,))
    p.start()
    print(q.get()) #这里prints "[42, None, 'hello']"
    p.join()

    #支持Pipe

def f3(conn):
    conn.send([43,None,'hello'])
    conn.close()

if __name__ == '__main__':
    parent_conn,child_conn=Pipe()
    p=Process(target=f3,args=(child_conn,))
    p.start()
    print(parent_conn.recv()) # 这里prints "[42, None, 'hello']"
    p.join()

    #支持Pool， 雇一群worker来干活

def f4(x):
    return x*x

if __name__ == '__main__':
    pool=Pool(processes=4) # start 4 worker processes
    result=pool.apply_async(f4,(10,)) # evaluate "f(10)" asynchronously
    try:
        print(result.get(timeout=1))
    except TimeoutError:
        pass
    print(pool.map(f4,range(10)))
    it=pool.imap(f4,range(10))
    print(it.next())
    print(it.next())
    print(it.next(timeout=1)) # raises TimeoutError
    result=pool.apply_async(time.sleep,(10,))
    print(result.get(timeout=1))

注意事项:

* 在UNIX平台上，当某个进程终结之后，该进程需要被其父进程调用wait，否则进程成为僵尸进程(Zombie)。所以，有必要对每个Process对象调用join()方法 (实际上等同于wait)。对于多线程来说，由于只有一个进程，所以不存在此必要性。

* multiprocessing提供了threading包中没有的IPC(比如Pipe和Queue)，效率上更高。应优先考虑Pipe和Queue，避免使用Lock/Event/Semaphore/Condition等同步方式 (因为它们占据的不是用户进程的资源)。

* 多进程应该避免共享资源。在多线程中，我们可以比较容易地共享资源，比如使用全局变量或者传递参数。在多进程情况下，由于每个进程有自己独立的内存空间，以上方法并不合适。此时我们可以通过共享内存和Manager的方法来共享资源。但这样做提高了程序的复杂度，并因为同步的需要而降低了程序的效率。

Reference:

[1] http://www.ibm.com/developerworks/aix/library/au-multiprocessing

[2] http://docs.python.org/2/library/multiprocessing.html

python中的多进程处理

1)Process
要创建一个Process是很简单的。

from multiprocessing import Process
def f(name):
print('hello', name)
if __name__ == '__main__':
p = Process(target=f, args=('bob',))
p.start()
p.join()

要获得一个Process的进程ID也是很简单的。

from multiprocessing import Process
import os
def info(title):
print title
print 'module name:', __name__
print 'process id:', os.getpid()
def f(name):
info('function f')
print 'hello', name
if __name__ == '__main__':
info('main line')
p = Process(target=f, args=('bob',))
p.start()
p.join()

创建进程：multiprocessing.Process([group[, target[, name[, args[, kargs]]]]])
参数：
group:    None,它的存在仅仅是为了与threading.Thread兼容
target:   一般是函数
name:     进程名
args: 函数的参数
kargs:    keywords参数

函数：
run()                  默认的run()函数调用target的函数，你也可以在子类中覆盖该函数
start()                启动该进程
join([timeout])        父进程被停止，直到子进程被执行完毕。
                         当timeout为None时没有超时，否则有超时。
                         进程可以被join很多次，但不能join自己
is_alive()
terminate()            结束进程。
                         在Unix上使用的是SIGTERM
                         在Windows平台上使用TerminateProcess

属性：
name                   进程名
daemon       守护进程
pid    进程ID
exitcode 如果进程还没有结束，该值为None
authkey

2)Queue
Queue类似于queue.Queue，一般用来进程间交互信息
例子：

from multiprocessing import Process, Queue
def f(q):
q.put([42, None, 'hello'])
if __name__ == '__main__':
q = Queue()
p = Process(target=f, args=(q,))
p.start()
print(q.get()) # prints "[42, None, 'hello']"
p.join()

注意：Queue是进程和线程安全的。
Queue实现了queue.Queue的大部分方法，但task_done()和join()没有实现。
创建Queue:multiprocessing.Queue([maxsize])
函数：
qsize()                             返回Queue的大小
empty()                             返回一个boolean值表示Queue是否为空
full()                              返回一个boolean值表示Queue是否满
put(item[, block[, timeout]])
put_nowait(item)
get([block[, timeout]])
get_nowait()
get_no_wait()

close()                             表示该Queue不在加入新的元素
join_thread()
cancel_join_thread()

3)JoinableQueue
创建：multiprocessing.JoinableQueue([maxsize])
task_done()
join()

4)Pipe

from multiprocessing import Process, Pipe
def f(conn):
conn.send([42, None, 'hello'])
conn.close()
if __name__ == '__main__':
parent_conn, child_conn = Pipe()
p = Process(target=f, args=(child_conn,))
p.start()
print(parent_conn.recv()) # prints "[42, None, 'hello']"
p.join()

multiprocessing.Pipe([duplex]) 返回一个Connection对象

5)异步化synchronization

from multiprocessing import Process, Lock
def f(l, i):
l.acquire()
print('hello world', i)
l.release()
if __name__ == '__main__':
lock = Lock()
for num in range(10):
Process(target=f, args=(lock, num)).start()

6)Shared Memory

from multiprocessing import Process, Value, Array
def f(n, a):
n.value = 3.1415927
for i in range(len(a)):
a[i] = -a[i]
if __name__ == '__main__':
num = Value('d', 0.0)
arr = Array('i', range(10))
p = Process(target=f, args=(num, arr))
p.start()
p.join()
print(num.value)
print(arr[:])

1>Value
2>Array

7)Manager

from multiprocessing import Process, Manager
def f(d, l):
d[1] = '1'
d['2'] = 2
d[0.25] = None
l.reverse()
if __name__ == '__main__':
manager = Manager()
d = manager.dict()
l = manager.list(range(10))
p = Process(target=f, args=(d, l))
p.start()
p.join()
print(d)
print(l)

8)Pool

from multiprocessing import Pool
def f(x):
return x*x
if __name__ == '__main__':
pool = Pool(processes=4) # start 4 worker processes
result = pool.apply_async(f, [10]) # evaluate "f(10)" asynchronously
print result.get(timeout=1) # prints "100" unless your computer is *very* slow
print pool.map(f, range(10)) # prints "[0, 1, 4,..., 81]"

multiprocessing.Pool([processes[, initializer[, initargs]]])

函数：
apply(func[, args[, kwds]])
apply_async(func[, args[, kwds[, callback]]])
map(func,iterable[, chunksize])
map_async(func,iterable[, chunksize[, callback]])
imap(func, iterable[, chunksize])
imap_unordered(func, iterable[, chunksize])
close()
terminate()
join()

from multiprocessing import Pool
def f(x):
return x*x
if __name__ == '__main__':
pool = Pool(processes=4) # start 4 worker processes
result = pool.apply_async(f, (10,)) # evaluate "f(10)" asynchronously
print(result.get(timeout=1)) # prints "100" unless your computer is *very* slow
print(pool.map(f, range(10))) # prints "[0, 1, 4,..., 81]"
it = pool.imap(f, range(10))
print(next(it)) # prints "0"
print(next(it)) # prints "1"
print(it.next(timeout=1)) # prints "4" unless your computer is *very* slow
import time
result = pool.apply_async(time.sleep, (10,))
print(result.get(timeout=1)) # raises TimeoutError

9)杂项
multiprocessing.active_children()          返回所有活动子进程的列表
multiprocessing.cpu_count()                返回CPU数目
multiprocessing.current_process()          返回当前进程对应的Process对象
multiprocessing.freeze_support()
multiprocessing.set_executable()

10)Connection对象
send(obj)
recv()
fileno()
close()
poll([timeout])
send_bytes(buffer[, offset[, size]])
recv_bytes([maxlength])
recv_bytes_info(buffer[, offset])