python多进程编程

阅读目录

---

如果想要充分地使用多核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)

常见的关于multiprocessing的用法基本就是这些，更多关于multiprocessing可以参照源码

---

参考文献

1. https://morvanzhou.github.io/tutorials/python-basic/multiprocessing/1-why/
2. http://outofmemory.cn/code-snippet/2266/Python-duojincheng-usage-gongxiangneicun-process-between-share-data
3. https://www.cnblogs.com/Xjng/p/4902514.html
4. http://www.cnblogs.com/kaituorensheng/p/4445418.html#_label2