阅读目录
如果想要充分地使用多核CPU的资源,在python中大部分情况需要使用多进程。Python提供了非常好用的多进程包multiprocessing,只需要定义一个函数,Python会完成其他所有事情。借助这个包,可以轻松完成从单进程到并发执行的转换。multiprocessing支持子进程、通信和共享数据、执行不同形式的同步,提供了Process、Queue、Pipe、Lock等组件
添加进程 Process
- 看一个简单例子
import multiprocessing as mp
def job(a,d):
print('aaaaa')
if __name__=='__main__':
# 创建进程,被调用的函数没有括号,被调用的函数的参数放在args(…)中
p1 = mp.Process(target=job,args=(1,2))
# 查看cpu核数
print(mp.cpu_count())
# 启动进程
p1.start()
# 连接进程
p1.join()
print(p1.pid)
print(p1.name)
print(p1.is_alive())
创建进程的类:Process([group [, target [, name [, args [, kwargs]]]]]),target表示调用对象,args表示调用对象的位置参数元组。kwargs表示调用对象的字典。name为别名。group实质上不使用。
方法:is_alive()、join([timeout])、run()、start()、terminate()。其中,Process以start()启动某个进程。
属性:authkey、daemon(要通过start()设置)、exitcode(进程在运行时为None、如果为–N,表示被信号N结束)、name、pid。其中daemon是父进程终止后自动终止,且自己不能产生新进程,必须在start()之前设置。
- 创建多个进程
import multiprocessing
import time
def worker_1(interval):
print "worker_1"
time.sleep(interval)
print "end worker_1"
def worker_2(interval):
print "worker_2"
time.sleep(interval)
print "end worker_2"
def worker_3(interval):
print "worker_3"
time.sleep(interval)
print "end worker_3"
if __name__ == "__main__":
p1 = multiprocessing.Process(target = worker_1, args = (2,))
p2 = multiprocessing.Process(target = worker_2, args = (3,))
p3 = multiprocessing.Process(target = worker_3, args = (4,))
p1.start()
p2.start()
p3.start()
print("The number of CPU is:" + str(multiprocessing.cpu_count()))
for p in multiprocessing.active_children():
print("child p.name:" + p.name + "\tp.id" + str(p.pid))
print "END!!!!!!!!!!!!!!!!!"
输出结果
worker_1
worker_2
worker_3
The number of CPU is:4
child p.name:Process-2 p.id3758
child p.name:Process-1 p.id3757
child p.name:Process-3 p.id3759
END!!!!!!!!!!!!!!!!!
end worker_1
end worker_2
end worker_3
进程池 Pool
在利用Python进行系统管理的时候,特别是同时操作多个文件目录,或者远程控制多台主机,并行操作可以节约大量的时间。当被操作对象数目不大时,可以直接利用multiprocessing中的Process动态成生多个进程,十几个还好,但如果是上百个,上千个目标,手动的去限制进程数量却又太过繁琐,此时可以发挥进程池的功效。
Pool可以提供指定数量的进程,供用户调用,当有新的请求提交到pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到规定最大值,那么该请求就会等待,直到池中有进程结束,才会创建新的进程来它。
import multiprocessing as mp
def job(x):
return x*x
def multicore():
# 定义CPU核数量为3
pool = mp.Pool(processes=3)
res = pool.map(job, range(10))
print(res)
if __name__ == '__main__':
multicore()
# 输出结果
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Pool除了map()外,还有可以返回结果的方式,那就是apply_async().
apply_async()中只能传递一个值,它只会放入一个核进行运算,但是传入值时要注意是可迭代的,所以在传入值后需要加逗号, 同时需要用get()方法获取返回值
import multiprocessing as mp
def job(x):
return x*x
def multicore():
pool = mp.Pool()
res = pool.map(job, range(10))
print(res)
res = pool.apply_async(job, (2,))
# 用get获得结果
print(res.get())
# 迭代器,i=0时apply一次,i=1时apply一次等等
multi_res = [pool.apply_async(job, (i,)) for i in range(10)]
# 从迭代器中取出
print([res.get() for res in multi_res])
if __name__ == '__main__':
multicore()
"""
输出结果
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
4
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
"""
下面再看一组例子,了解非阻塞和阻塞之间的区别
使用进程池(非阻塞)
import multiprocessing
import time
def func(x):
print('start...')
time.sleep(2)
print x*x
print('end...')
if __name__ == "__main__":
pool = multiprocessing.Pool(processes = 3)
for i in xrange(4):
# 非阻塞式
pool.apply_async(func, (i, )) #维持执行的进程总数为processes,当一个进程执行完毕后会添加新的进程进去
print "Mark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~"
pool.close()
#调用join之前,先调用close函数,否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
pool.join()
print "Sub-process(es) done."
'''
输出结果
Mark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~
start
start
start
01
endend
start
4
end
9
end
Sub-process(es) done.
'''
使用进程池(阻塞)
import multiprocessing
import time
def func(x):
print('start')
time.sleep(2)
print x*x
print('end')
if __name__ == "__main__":
pool = multiprocessing.Pool(processes = 3)
for i in xrange(4):
# 阻塞式
pool.apply(func, (i, )) #维持执行的进程总数为processes,当一个进程执行完毕后会添加新的进程进去
print "Mark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~"
pool.close()
#调用join之前,先调用close函数,否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
pool.join()
print "Sub-process(es) done."
'''
输出结果
start
0
end
start
1
end
start
4
end
start
9
end
Mark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~
Sub-process(es) done.
'''
- apply_async(func[, args[, kwds[, callback]]]) 它是非阻塞,apply(func[,args[, kwds]])是阻塞的
- close() 关闭pool,使其不在接受新的任务。
- terminate() 结束工作进程,不在处理未完成的任务。
- join() 主进程阻塞,等待子进程的退出, join方法要在close或terminate之后使用。
- 执行说明:创建一个进程池pool,并设定进程的数量为3,xrange(4)会相继产生四个对象[0, 1, 2, 3],四个对象被提交到pool中.
- apply_async异步非阻塞式:因pool指定进程数为3,所以0、1、2会直接送到进程中执行,当其中一个执行完事后才空出一个进程处理对象3。因为为非阻塞,主函数会自己执行自个的,不搭理进程的执行,所以运行完for循环后直接输出“mMsg:Mark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~”,主程序在pool.join()处等待各个进程的结束
- apply阻塞:意思就是等待当前子进程执行完毕后,在执行下一个进程。首先主进程开始运行,碰到子进程,操作系统切换到子进程,等待子进程运行结束后,在切换到另外一个子进程,直到所有子进程运行完毕。然后在切换到主进程,运行剩余的部分。这样好像和单进程执行没有什么区别了
共享内存 shared memory
用共享内存才能让CPU之间有交流.
在Python的mutiprocessing中,有还有一个Array类,可以和共享内存交互,来实现在进程之间共享数据。它的原理是:先启动一个ManagerServer进程,这个进程是阻塞的,它监听一个socket,然后其他进程(ManagerClient)通过socket来连接到ManagerServer,实现通信
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__':
# 其中d和i参数用来设置数据类型的,d表示一个双精浮点类型,i表示一个带符号的整型。更多的形式请查看https://docs.python.org/3/library/array.html
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[:]
'''
输出结果:
3.1415927
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
'''
也可以使用Manager类。Manager是一种较为高级的多进程通信方式,它能支持Python支持的的任何数据结构。
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
'''
输出结果:
{0.25: None, 1: '1', '2': 2}
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
'''
进程锁 Lock
当多个进程需要访问共享资源的时候,Lock可以用来避免访问的冲突。
- 首先看看当有多个进程访问共享资源的时候,不加进程锁的情况
import multiprocessing as mp
import time
def job(v, num):
for _ in range(5):
# 暂停0.1秒,让输出效果更明显
time.sleep(0.1)
# v.value获取共享变量值
v.value += num
print(v.value, end="")
def multicore():
# 定义共享变量
v = mp.Value('i', 0)
p1 = mp.Process(target=job, args=(v,1))
# 设定不同的number看如何抢夺内存
p2 = mp.Process(target=job, args=(v,3))
p1.start()
p2.start()
p1.join()
p2.join()
if __name__ == '__main__':
multicore()
'''
输出结果;
1
4
5
8
9
12
13
16
17
20
'''
在上面的代码中,我们定义了一个共享变量v,两个进程都可以对它进行操作。 在job()中我们想让v每隔0.1秒输出一次累加num的结果,但是在两个进程p1和p2 中设定了不同的累加值。我们可以看到,进程1和进程2在相互抢着使用共享内存v
- 使用加进程锁来解决多进程访问共享资源的冲突
# coding:utf-8
import multiprocessing as mp
import time
def job(v, num, l):
# 锁住
l.acquire()
for _ in range(5):
time.sleep(0.1)
# 获取共享内存
v.value += num
print(v.value)
# 释放
l.release()
def multicore():
# 定义一个进程锁
l = mp.Lock()
# 定义共享内存
v = mp.Value('i', 0)
# 需要将lock传入
p1 = mp.Process(target=job, args=(v,1,l))
p2 = mp.Process(target=job, args=(v,3,l))
p1.start()
p2.start()
p1.join()
p2.join()
if __name__ == '__main__':
multicore()
'''输出结果
1
2
3
4
5
8
11
14
17
20
'''
显然,进程锁保证了进程p1的完整运行,然后才进行了进程p2的运行
控制对共享资源的访问数量Semaphore
看一段代码
# coding:utf-8
import multiprocessing
import time
def worker(s, i):
s.acquire()
print(multiprocessing.current_process().name + "acquire");
time.sleep(i)
print(multiprocessing.current_process().name + "release\n");
s.release()
if __name__ == "__main__":
# 控制最大访问量为2
s = multiprocessing.Semaphore(2)
for i in range(5):
p = multiprocessing.Process(target = worker, args=(s, i*2))
p.start()
'''输出结果
Process-1acquire
Process-1release
Process-2acquire
Process-3acquire
Process-2release
Process-4acquire
Process-3release
Process-5acquire
Process-4release
Process-5release
'''
- 结果说明:首先通过semaphore控制worker最大的并发数量为2,也就是说同时最多只能在两个进程上执行worker的任务。所以根据结果,process-2和process-3执行worker任务的时候,其他进程必须等待。当process-2完成的时候,process-4立即执行worker任务,当process-3完成的时候,process-5立刻执行worker任务。(process-1没有sleep,所以process-1执行的速度很快,以至于process-2还没开始,process-1已经执行完了)
进程间通信Queue(存储进程输出)
-
Queue是多进程安全的队列,可以使用Queue实现多进程之间的数据传递。put方法用以插入数据到队列中,put方法还有两个可选参数:blocked和timeout。如果block为True(默认值),并且timeout为正值,该方法会阻塞timeout指定的时间,直到该队列有剩余的空间。如果超时,会抛出Queue.Full异常。如果block为False,但该Queue已满,会立即抛出Queue.Full异常。
-
get方法可以从队列读取并且删除一个元素。同样,get方法有两个可选参数:block和timeout。如果blocked为True(默认值),并且timeout为正值,那么在等待时间内没有取到任何元素,会抛出Queue.Empty异常。如果block为False,有两种情况存在,如果Queue有一个值可用,则立即返回该值,否则,如果队列为空,则立即抛出Queue.Empty异常。Queue的一段示例代码
import multiprocessing as mp
def job(q):
res=0
for i in range(10):
res+=i+i**2+i**3
q.put(res, block=False) #queue
if __name__=='__main__':
q = mp.Queue()
p1 = mp.Process(target=job,args=(q,))
p2 = mp.Process(target=job,args=(q,))
p1.start()
p2.start()
p1.join()
p2.join()
res1 = q.get(block=False)
res2 = q.get(block=False)
print(res1)
print(res2)
进程间通信Event
首先来看一段代码
# coding:utf-8
import multiprocessing
import time
def wait_for_event(e):
print("wait_for_event: starting")
e.wait()
# 打印出Flag的状态
print("wairt_for_event: e.is_set()->" + str(e.is_set()))
def wait_for_event_timeout(e, t):
print("wait_for_event_timeout:starting")
e.wait(timeout=t)
# 打印出Flag的状态
print("wait_for_event_timeout:e.is_set->" + str(e.is_set()))
if __name__ == "__main__":
# 定义一个类事件对象
e = multiprocessing.Event()
# 阻塞式,直到Flag=True
w1 = multiprocessing.Process(name = "block",
target = wait_for_event,
args = (e,))
# 非阻塞式
w2 = multiprocessing.Process(name = "non-block",
target = wait_for_event_timeout,
args = (e, 2))
w1.start()
w2.start()
time.sleep(3)
# 设置Flag=True
e.set()
print("main: event is set")
'''输出结果
wait_for_event: starting
wait_for_event_timeout:starting
wait_for_event_timeout:e.is_set->False
main: event is set
wairt_for_event: e.is_set()->True
'''
- Event模块是一个类事件对象。这个对象管理这一个flag,初始的时候flag为False,可以使用set()方法让flag=True, 也可以用clear方法重置flag=False, wait()是阻塞的方法,直到flag=True才往下执行
- clear(): 重置flag=False
- is_set(): 当且仅当flag=True的时候,返回True
- set(): 重置flag=True, 所有wait()被唤醒,继续执行
- wait(timeout=None):当flag为False的时候,一直是阻塞状态;如果等待时间超过了timeout或者flag=True,执行后续的代码
进程间通信Pipe
- Pipe方法返回(conn1, conn2)代表一个管道的两个端。Pipe方法有duplex参数,如果duplex参数为True(默认值),那么这个管道是全双工模式,也就是说conn1和conn2均可收发。duplex为False,conn1只负责接受消息,conn2只负责发送消息。
- send和recv方法分别是发送和接受消息的方法。例如,在全双工模式下,可以调用conn1.send发送消息,conn1.recv接收消息。如果没有消息可接收,recv方法会一直阻塞。如果管道已经被关闭,那么recv方法会抛出EOFError。
# coding:utf-8
import multiprocessing
import time
def proc1(pipe):
while True:
for i in xrange(10000):
print "send: %s" %(i)
pipe.send(i)
time.sleep(i)
def proc2(pipe):
while True:
print "proc2 rev:", pipe.recv()
time.sleep(1)
if __name__ == "__main__":
pipe = multiprocessing.Pipe()
p1 = multiprocessing.Process(target=proc1, args=(pipe[0],))
p2 = multiprocessing.Process(target=proc2, args=(pipe[1],))
p1.start()
p2.start()
p1.join()
p2.join()
'''输出结果
send: 0
send: 1
proc2 rev: 0
send: 2
proc2 rev: 1
proc2 rev: 2
send: 3
proc2 rev: 3
send: 4
proc2 rev: 4
send: 5
proc2 rev: 5
send: 6
proc2 rev: 6
'''
代码实例:
def process_one_task(task):
pass
def prepare_tasks():
pass
def init(l):
global lock
lock = l
def run_muliprocessor(tasks, processor_num=1):
if processor_num > 1:
lock = multiprocessing.Lock()
pool = multiprocessing.Pool(processor_num, initializer=init, initargs=(lock,))
pool.map(process_one_task, tasks)
pool.close()
pool.join()
else:
for task in tasks:
process_one_task(task)
break
if __name__ == 'main':
run_multiprocessor(tasks,10)
daemonic process
- The process’s daemon flag, a Boolean value, This must be set before start() is called.
- The initial value is inherited from the creating process.
- When a process exits, it attempts to terminate all of its daemonic child process.
- Note that a daemonic process is not allowed to create child processes. Otherwise a daemonic process would leave its children orphaned if it gets terminated when its parent process exits.
一般来说,multiprocessing.process的daemon属性默认都是为True, 且不可更改,所以说理论上来讲,在用multiporcessing进行多进程编程的时候,我们不能让子进程开启多进程,因为daemonic process is not allowed to create child processes. 为了实现让子进程也可以开启多进程任务,可以将子进程的daemon属性设为False, 这需要额外的工作。看下面一个例子
import time
import multiprocessing
import multiprocessing.pool
class NoDaemonProcess(multiprocessing.Process):
def _get_daemon(self):
"""always return False"""
return False
def _set_daemon(self, value):
pass
daemon = property(_get_daemon, _set_daemon)
class MyPool(multiprocessing.pool.Pool):
Process = NoDaemonProcess
def run_non_daemon_multiprocessor(tasks_list):
print("creating 3 non-daemon workers and jobs in main process")
pool = MyPool(3)
pool.map(run_daemon_multiprocessor, tasks_list)
pool.close()
pool.join()
def run_daemon_multiprocessor(tasks):
print(f'creating 2 daemon workers and jobs in children, tasks: {tasks}')
pool = multiprocessing.Pool(2)
pool.map(run, tasks)
pool.close()
pool.join()
def run(task):
print(f'running task {task}')
time.sleep(2)
if __name__ == '__main__':
tasks_list = [[11,12], [21, 22], [31, 32]]
run_non_daemon_multiprocessor(tasks_list)
"""
creating 3 non-daemon workers and jobs in main process
creating 2 daemon workers and jobs in children, tasks: [11, 12]
creating 2 daemon workers and jobs in children, tasks: [21, 22]
creating 2 daemon workers and jobs in children, tasks: [31, 32]
running task 31
running task 11
running task 21
running task 32
running task 12
running task 22
"""
通过继承Process和Pool类,将daemon属性进行修改,强制返回False, 这样就可以让子进程进行开启多进程任务。
一个更加大胆的想法是,是否可以不断的让子进程开启多进程呢,我们做了如下实验,代码如下
import time
import multiprocessing
import multiprocessing.pool
class NoDaemonProcess(multiprocessing.Process):
def _get_daemon(self):
"""always return False"""
return False
def _set_daemon(self, value):
pass
daemon = property(_get_daemon, _set_daemon)
class MyPool(multiprocessing.pool.Pool):
Process = NoDaemonProcess
def run_non_daemon_multiprocessor(tasks_lists):
print("creating 2 non-daemon workers and jobs in main process")
pool = MyPool(2)
pool.map(run_non_daemon_multiprocessor2, tasks_lists)
pool.close()
pool.join()
def run_non_daemon_multiprocessor2(tasks_list):
print("creating 2 non-daemon workers and jobs in main process")
pool = MyPool(2)
pool.map(run_daemon_multiprocessor, tasks_list)
pool.close()
pool.join()
def run_daemon_multiprocessor(tasks):
print(f'creating 2 daemon workers and jobs in children, tasks: {tasks}')
pool = multiprocessing.Pool(2)
pool.map(run, tasks)
pool.close()
pool.join()
def run(task):
print(f'running task {task}')
time.sleep(2)
if __name__ == '__main__':
tasks_lists = [[[11,12], [21, 22]], [[31, 32], [41, 42]]]
run_non_daemon_multiprocessor(tasks_lists)
"""
creating 2 non-daemon workers and jobs in main process
creating 2 non-daemon workers and jobs in main process
creating 2 non-daemon workers and jobs in main process
creating 2 daemon workers and jobs in children, tasks: [31, 32]
creating 2 daemon workers and jobs in children, tasks: [11, 12]
creating 2 daemon workers and jobs in children, tasks: [21, 22]
creating 2 daemon workers and jobs in children, tasks: [41, 42]
running task 11
running task 41
running task 21
running task 22
running task 12
running task 31
running task 42
running task 32
"""
可以看出只要是non-daemon process, 就可以有child process, 也就是说可以开始多进程,但是这样做的风险是当父进程杀死后,子进程可能还在运行,而且要注意控制进程的数量,否则可能cpu负载会很大
常见的关于multiprocessing的用法基本就是这些,更多关于multiprocessing可以参照源码
参考文献
- https://morvanzhou.github.io/tutorials/python-basic/multiprocessing/1-why/
- http://outofmemory.cn/code-snippet/2266/Python-duojincheng-usage-gongxiangneicun-process-between-share-data
- https://www.cnblogs.com/Xjng/p/4902514.html
- http://www.cnblogs.com/kaituorensheng/p/4445418.html#_label2