Python多任务-进程

程序是以二进制形式存放在硬盘之上的，当启动程序将数据（代码）加载至内存中就称之为进程。
进程是一组资源（包括：代码，显示器，硬盘，网络…）的统称。线程也能实现多任务，但相对进程来说是轻量级的。
实际上进程是一个资源分配的单位，实际上操纵数据的是线程，一个进程至少一个主线程。代码至上而下运行的时候实际上就是主线程在运行，当遇到一个Thread对象调用start方法时，就再开一个线程。当遇到一个Process对象调用start方法时就将当前进程的资源复制一份到内存的一个区域中，以一个新的进程去运行，它拥有独立的内存单元，这就叫子进程。子进程因为有自己的资源，所以不与父进程共享全局变量。
简单的来说进程是资源分配的单位，而线程是操作系统调度的单位。

# -*- coding:utf-8 -*-
from multiprocessing import Process
import os
import time

nums = [11, 22]

def work1():
"""子进程要执行的代码"""
print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
for i in range(3):
nums.append(i)
time.sleep(1)
print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))

def work2():
"""子进程要执行的代码"""
print("in process2 pid=%d ,nums=%s" % (os.getpid(), nums))

if __name__ == '__main__':
p1 = Process(target=work1)
p1.start()
p1.join()

p2 = Process(target=work2)
p2.start()

结果：

in process1 pid=7956 ,nums=[11, 22]
in process1 pid=7956 ,nums=[11, 22, 0]
in process1 pid=7956 ,nums=[11, 22, 0, 1]
in process1 pid=7956 ,nums=[11, 22, 0, 1, 2]
in process2 pid=22332 ,nums=[11, 22]

Process语法结构如下：

Process([group [, target [, name [, args [, kwargs]]]]])

target：如果传递了函数的引用，可以任务这个子进程就执行这里的代码
args：给target指定的函数传递的参数，以元组的方式传递
kwargs：给target指定的函数传递命名参数
name：给进程设定一个名字，可以不设定
group：指定进程组，大多数情况下用不到
Process创建的实例对象的常用方法：

start()：启动子进程实例（创建子进程）
is_alive()：判断进程子进程是否还在活着
join([timeout])：是否等待子进程执行结束，或等待多少秒
terminate()：不管任务是否完成，立即终止子进程
Process创建的实例对象的常用属性：

name：当前进程的别名，默认为Process-N，N为从1开始递增的整数
pid：当前进程的pid（进程号）

既然进程间数据不共享那么进程间又是怎么通信的呢
操作系统提供了很多机制实现进程间通信，可以使用文件，socket，以及内存。在内存中划分一块区域，一个进程写另一个进程读就可以完成进程间通信了。
##Queue的使用
可以使用multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息列队程序。

from multiprocessing import Process, Queue
import os, time, random

# 写数据进程执行的代码:
def write(q):
for value in ['A', 'B', 'C']:
print('Put %s to queue...' % value)
q.put(value)
time.sleep(random.random())

# 读数据进程执行的代码:
def read(q):
while True:
if not q.empty():
value = q.get(True)
print('Get %s from queue.' % value)
time.sleep(random.random())
else:
break

if __name__=='__main__':
# 父进程创建Queue，并传给各个子进程：
q = Queue()
pw = Process(target=write, args=(q,))
pr = Process(target=read, args=(q,))
# 启动子进程pw，写入:
pw.start()
# 等待pw结束:
pw.join()
# 启动子进程pr，读取:
pr.start()
pr.join()
# pr进程里是死循环，无法等待其结束，只能强行终止:
print('')
print('所有数据都写入并且读完')

结果：

Put A to queue...
Put B to queue...
Put C to queue...
Get A from queue.
Get B from queue.
Get C from queue.

所有数据都写入并且读完

进程池

当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程，但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。

初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会用之前的进程来执行新的任务
任务数固定用Process创建子进程，不固定则用Pool来创建进程池

通过进程池(Pool)创建的子进程，主进程并不会等子进程执行完才退出，这时候就需要调用po.join堵塞主进程直到子进程执行完毕。

multiprocessing.Pool常用函数解析：

apply_async(func[, args[, kwds]]) ：使用非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给func的参数列表，kwds为传递给func的关键字参数列表；
close()：关闭Pool，使其不再接受新的任务；
terminate()：不管任务是否完成，立即终止；
join()：主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用；

子进程如果发生异常并不会产生异常信息
注意：进程池之间想要通信不能使用multiprocessing模块的Queue，而是使用multiprocessing.Manager()中的Queue()，否则会得到一条如下的错误信息：

RuntimeError: Queue objects should only be shared between processes through inheritance.

示例：

# -*- coding:utf-8 -*-

# 修改import中的Queue为Manager
from multiprocessing import Manager,Pool
import os,time,random

def reader(q):
print("reader启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
for i in range(q.qsize()):
print("reader从Queue获取到消息：%s" % q.get(True))

def writer(q):
print("writer启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
for i in "itcast":
q.put(i)

if __name__=="__main__":
print("(%s) start" % os.getpid())
q = Manager().Queue()  # 使用Manager中的Queue
po = Pool()
po.apply_async(writer, (q,))

time.sleep(1)  # 先让上面的任务向Queue存入数据，然后再让下面的任务开始从中取数据

po.apply_async(reader, (q,))
po.close()
po.join()
print("(%s) End" % os.getpid())

结果:

(21424) start
writer启动(25556),父进程为(21424)
reader启动(9808),父进程为(21424)
reader从Queue获取到消息：i
reader从Queue获取到消息：t
reader从Queue获取到消息：c
reader从Queue获取到消息：a
reader从Queue获取到消息：s
reader从Queue获取到消息：t
(21424) End