Python进程

Python在2.6引入了多进程的机制，并提供了丰富的组件及api以方便编写并发应用。multiprocessing包的组件Process, Queue, Pipe, Lock等组件提供了与多线程类似的功能。使用这些组件，可以方便地编写多进程并发程序。

多进程实例：

import os
from multiprocessing import Process

def info(title):
print(title)
print('module name:', __name__)
print('parent process:', os.getppid())
print('process id:', os.getpid())
print("\n\n")

def f(name):
info('\033[31;1mfunction f\033[0m')
print('hello', name)

if __name__ == '__main__':
info('\033[32;1mmain process line\033[0m')
p = Process(target=info, args=('bob',))
p.start()
p.join()

实例化一个Process必须要指定target和args。target是新的进程的入口方法，可以认为是main方法。args是该方法的参数列表。启动进程类似于启动Thread，必须要调用start方法。也可以继承Process，覆盖run方法，在run方法中实现该进程的逻辑。调用join方法会阻塞当前调用进程，直到被调用进程运行结束。
手工终止一个进程可以调用terminate方法，在UNIX系统中，该方法会发送SIGTERM信号量，而在windows系统中，会借助TerminateProcess方法。需要注意的是，exit处理逻辑并不会被执行，该进程的子进程不会被终止，他们只会变成孤儿进程。

进程间通讯

Queue

Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。put方法用以插入数据到队列中，put方法还有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常。
get方法可以从队列读取并且删除一个元素。同样，get方法有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出Queue.Empty异常。如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常。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,))
p2 = Process(target=f, args=(q,))
p.start()
p2.start()
print('data1:',q.get())    # prints "[42, None, 'hello']"
print('data2:',q.get())
p.join()

[b]Pipes[/b]

Pipe方法返回(conn1, conn2)代表一个管道的两个端。Pipe方法有duplex参数，如果duplex参数为True(默认值)，那么这个管道是全双工模式，也就是说conn1和conn2均可收发。duplex为False，conn1只负责接受消息，conn2只负责发送消息。
send和recv方法分别是发送和接受消息的方法。例如，在全双工模式下，可以调用conn1.send发送消息，conn1.recv接收消息。如果没有消息可接收，recv方法会一直阻塞。如果管道已经被关闭，那么recv方法会抛出EOFError。

from multiprocessing import Process, Pipe

def send(conn):
conn.send("Hello World")
conn.close()

if __name__ == '__main__':
parent_conn, child_conn = Pipe()
p = Process(target=send, args=(child_conn,))
p.start()
print(parent_conn.recv())

Managers

from multiprocessing import Process, Manager

def f(d, l):
d[1] = '1'
d['2'] = 2
d[0.25] = None
l.append('a')
print(l)

if __name__ == '__main__':
with Manager() as manager:
d = manager.dict()
l = manager.list(range(5))
p_list = []
for i in range(10):
p = Process(target=f, args=(d, l))
p.start()
p_list.append(p)
for res in p_list:
res.join()

print(d)
print(l)

进程同步
multiprocessing包提供了Condition, Event, Lock, RLock, Semaphore等组件可用于同步。下面是使用Lock的一个示例：

from multiprocessing import Process, Lock

def f(l, i):
l.acquire()
try:
print('hello world', i)
finally:
l.release()

if __name__ == '__main__':
lock = Lock()

for num in range(10):
Process(target=f, args=(lock, num)).start()

进程池　　

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

apply_async

from  multiprocessing import Process,Pool,freeze_support
import time

def Foo(i):
time.sleep(2)
return i+100

def Bar(arg):
print('-->exec done:',arg)

if __name__ == '__main__':
freeze_support()
pool = Pool(3)
for i in range(10):
pool.apply_async(func=Foo, args=(i,),callback=Bar)  # 异步
#pool.apply(func=Foo, args=(i,))    # 同步无回调机制

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

本文出自 “纷繁中享受技术的简单喜悦” 博客，请务必保留此出处http://51enjoy.blog.51cto.com/8393791/1752206