设计并发程序的四个阶段（PCAM设计方法学）：
-
划分（Partitioning）:分解成小的任务，开拓并发性
-
通讯（Communication）：确定诸任务间的数据交换，监测划分的合理性；
-
组合（Agglomeration）：依据任务的局部性，组合成更大的任务；
-
映射（Mapping）：将每个任务分配到处理器上，提高算法的性能。
實例：
import multiprocessing
def make_data(queue, num, work_nums):
for i in range(num):
queue.put(i)
for i in range(work_nums):
queue.put(None)
def handle_data(queue, share_value, lock):
while True:
data = queue.get()
if data is None:
break
lock.acquire()
share_value.value = share_value.value + data
lock.release()
if __name__ == "__main__":
queue = multiprocessing.Queue() # 进程间通信所用
share_value = multiprocessing.Value("i", 0) # 进程间共享所用
lock = multiprocessing.Lock() # 进程间共享内存时，采用锁同步机制
num = 10000 #
work_nums = 5 # work进程个数
sub_process = [] # 处理数据进程集合
master_process = multiprocessing.Process(target=make_data, args=(queue, num, work_nums, )) # 生成数据进程
for i in range(work_nums):
sub_process1 = multiprocessing.Process(target=handle_data, args=(queue, share_value, lock,))
sub_process.append(sub_process1)
master_process.start()
for p in sub_process:
p.start()
#p.setDaemon(True)
master_process.join()
for p in sub_process:
p.join()
# 结果对比
result = 0
for i in range(num):
result = result + i
print("result should be " + str(result))
print("fact is " + str(share_value.value))输出结果：
result should be 49995000
fact is 49995000
Process([group [, target [, name [, args [, kwargs]]]]])
group: 线程组，目前还没有实现，库引用中提示必须是None；
target: 要执行的方法；
name: 进程名；
args/kwargs: 要传入方法的参数。
实例方法：
is_alive()：返回进程是否在运行。
join([timeout])：阻塞当前上下文环境的进程，直到调用此方法的进程终止或到达指定的timeout（可选参数）。
start()：进程准备就绪，等待CPU调度
run()：start()會调用run方法，如果实例进程时未制定传入target，start执行默认run()方法。
terminate()：不管任务是否完成，立即停止工作进程
属性：
daemon：和线程的setDeamon功能一样,設置守護進程
exitcode(进程在运行时为None、如果为–N，表示被信号N结束）
name：进程名字。
pid：进程号。
is/setDaemon(bool): 获取/设置是后台线程（默认前台线程（False））。（在start之前设置）
如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，主线程和后台线程均停止
如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
join有一个timeout参数：
- 当设置守护线程时【setDaemon(True)】，含义是主线程对于子线程等待timeout的时间将会杀死该子线程，最后退出程序。所以说，如果有10个子线程，全部的等待时间就是每个timeout的累加和。简单的来说，就是给每个子线程一个timeout的时间，让他去执行，时间一到，不管任务有没有完成，直接杀死。
- 没有设置守护线程时，主线程将会等待timeout的累加和这样的一段时间，时间一到，主线程结束，但是并没有杀死子线程，子线程依然可以继续执行，直到子线程全部结束，程序退出。
線程使用方法：
import threading
import time
#方法一：将要执行的方法作为参数传给Thread的构造方法
def action(arg):
time.sleep(1)
print 'the arg is:%s\r' %arg
for i in xrange(4):
t =threading.Thread(target=action,args=(i,))
t.start()
print 'main thread end!'
#方法二：从Thread继承，并重写run()
class MyThread(threading.Thread):
def __init__(self,arg):
super(MyThread, self).__init__()#注意：一定要显式的调用父类的初始化函数。
self.arg=arg
def run(self):#定义每个线程要运行的函数
time.sleep(1)
print 'the arg is:%s\r' % self.arg
for i in xrange(4):
t =MyThread(i)
t.start()
print 'main thread end!'ref :
