import os
# 注意，fork函数，只在Unix/Linux/Mac上运行，windows不可以
x = 0
ret = os.fork()
if ret<0:
    print("fork调用失败。")
elif ret == 0:
    print("我是子进程（%s），我的父进程是（%s）"%(os.getpid(),os.getppid()))
    x+=1
else:
    print("我是父进程（%s），我的子进程是（%s）"%(os.getpid(),ret))

print("父子进程都可以执行这里的代码")

结果：

fork 创建了一个子进程，调用fork函数会返回两个值分别给父子进程，子进程的值一定为0，父进程的值随机分配。

父进程分配的值是子进程的ID （PID）

程序中有两个函数：

os.getpid()####返回本进程ID
os.getppid()###返回上一级进程ID

1.2fork 执行顺序问题

fork创建进程后，父子进程执行的顺序由操作系统的调度算法决定。父进程先执行完后，程序退出。

import  os
import  time

ret = os.fork()

if ret == 0:
    print("---子进程开始---")
    time.sleep(5)
    print("---子进程结束---")
else:
    print("---父进程开始---")
    time.sleep(3)
    print("---父进程结束---")
print("---程序结束---")

结果

上面的程序中子进程中设置了5秒延时，父进程执行完后，程序退出。子进程接着执行（Linux命令行可显示效果）。

1.3fork 多进程修改全局变量

多进程中，每个进程中所有数据（包括全局变量）都各有拥有一份，互不影响。

import os
x = 0
ret = os.fork()
if ret<0:
    print("fork调用失败。")
elif ret == 0:
    print("我是子进程（%s），我的父进程是（%s）"%(os.getpid(),os.getppid()))
    x+=1
    print(x)
else:
    print("我是父进程（%s），我的子进程是（%s）"%(os.getpid(),ret))
    x+=1
    print(x)

print("父子进程都可以执行这里的代码")

1.4多次fork问题

#coding=utf-8
import os
import time

# 注意，fork函数，只在Unix/Linux/Mac上运行，windows不可以
pid = os.fork()
if pid == 0:
    print('哈哈1')
else:
    print('哈哈2')

pid = os.fork()
if pid == 0:
    print('哈哈3')
else:
    print('哈哈4')

time.sleep(1)

1.5fork 总结

fork只能支持类unix平台；

fork的父进程可以先退出；

父进程、子进程执行顺序没有规律，完全取决于操作系统的调度算法。

2、processing

由于Python是跨平台的，自然也应该提供一个跨平台的多进程支持。multiprocessing模块就是跨平台版本的多进程模块。

2.1Process基本用法

#coding=utf-8
from multiprocessing import Process
import os

# 子进程要执行的代码
def run_proc(name):
    print('子进程运行中，name= %s ,pid=%d...' % (name, os.getpid()))

if __name__=='__main__':
    print('父进程 %d.' % os.getpid())
    p = Process(target=run_proc, args=('test',))
    print('子进程将要执行')
    p.start()
    p.join()
    print('子进程已结束')

说明

创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动，这样创建进程比fork()还要简单。
join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。

Process语法结构如下：

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

target：表示这个进程实例所调用对象；
args：表示调用对象的位置参数元组；
kwargs：表示调用对象的关键字参数字典；
name：为当前进程实例的别名；
group：大多数情况下用不到；

Process类常用方法：

is_alive()：判断进程实例是否还在执行；
join([timeout])：是否等待进程实例执行结束，或等待多少秒；
start()：启动进程实例（创建子进程）；
run()：如果没有给定target参数，对这个对象调用start()方法时，就将执行对象中的run()方法；
terminate()：不管任务是否完成，立即终止；

Process类常用属性：

name：当前进程实例别名，默认为Process-N，N为从1开始递增的整数；
pid：当前进程实例的PID值；

实例：

#coding=utf-8
from multiprocessing import Process
import time
import os

#两个子进程将会调用的两个方法
def  worker_1(interval):
    print("worker_1,父进程(%s),当前进程(%s)"%(os.getppid(),os.getpid()))
    t_start = time.time()
    time.sleep(interval) #程序将会被挂起interval秒
    t_end = time.time()
    print("worker_1,执行时间为'%0.2f'秒"%(t_end - t_start))

def  worker_2(interval):
    print("worker_2,父进程(%s),当前进程(%s)"%(os.getppid(),os.getpid()))
    t_start = time.time()
    time.sleep(interval)
    t_end = time.time()
    print("worker_2,执行时间为'%0.2f'秒"%(t_end - t_start))

#输出当前程序的ID
print("进程ID：%s"%os.getpid())

#创建两个进程对象，target指向这个进程对象要执行的对象名称，
#args后面的元组中，是要传递给worker_1方法的参数，
#因为worker_1方法就一个interval参数，这里传递一个整数2给它，
#如果不指定name参数，默认的进程对象名称为Process-N，N为一个递增的整数
p1=Process(target=worker_1,args=(2,))
p2=Process(target=worker_2,name="dongGe",args=(1,))

#使用"进程对象名称.start()"来创建并执行一个子进程，
#这两个进程对象在start后，就会分别去执行worker_1和worker_2方法中的内容
p1.start()
p2.start()

#同时父进程仍然往下执行，如果p2进程还在执行，将会返回True
print("p2.is_alive=%s"%p2.is_alive())

#输出p1和p2进程的别名和pid
print("p1.name=%s"%p1.name)
print("p1.pid=%s"%p1.pid)
print("p2.name=%s"%p2.name)
print("p2.pid=%s"%p2.pid)

#join括号中不携带参数，表示父进程在这个位置要等待p1进程执行完成后，
#再继续执行下面的语句，一般用于进程间的数据同步，如果不写这一句，
#下面的is_alive判断将会是True，在shell（cmd）里面调用这个程序时
#可以完整的看到这个过程，大家可以尝试着将下面的这条语句改成p1.join(1)，
#因为p2需要2秒以上才可能执行完成，父进程等待1秒很可能不能让p1完全执行完成，
#所以下面的print会输出True，即p1仍然在执行
p1.join()
print("p1.is_alive=%s"%p1.is_alive())
执行结果:


进程ID：19866
p2.is_alive=True
p1.name=Process-1
p1.pid=19867
p2.name=dongGe
p2.pid=19868
worker_1,父进程(19866),当前进程(19867)
worker_2,父进程(19866),当前进程(19868)
worker_2,执行时间为'1.00'秒
worker_1,执行时间为'2.00'秒
p1.is_alive=False

2.2进程的创建-Process子类

创建新的进程还能够使用类的方式，可以自定义一个类，继承Process类，每次实例化这个类的时候，就等同于实例化一个进程对象。

from multiprocessing import Process
import time
import os
import  random

class MyProcess(Process):
    def run(self):
        print("子进程（%s）开始执行,父进程是%s"%(os.getpid(),os.getppid()))
        t_start = time.time()
        for i in range(random.randint(1,5)):
            print("---%d---"%i)
            time.sleep(2)
        t_stop = time.time()
        print("(%s)子进程执行结束，耗时%d秒"%(os.getpid(),t_stop-t_start))


if __name__ == "__main__":
    print("当前程序（%s）开始执行" % (os.getpid()))
    t_start = time.time()
    p1 = MyProcess()
    p1.start()
    p1.join()
    for i in range(random.randint(1, 2)):
        print("---main---")
        time.sleep(2)
    t_stop = time.time()
    print("(%s)当前程序执行结束，耗时%d秒" % (os.getpid(), t_stop - t_start))

3、进程池Pool

3.1Pool基本用法

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

初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来执行，请看下面的实例：

from multiprocessing import  Pool
import os
import random
import  time

def worker(num):
    print("%s子进程（%s）开始执行,父进程是%s"%(num,os.getpid(),os.getppid()))
    t_start = time.time()
    time.sleep(random.random()*2)
    t_stop = time.time()
    print("(%s)子进程%s执行结束，耗时%0.2f秒"%(num,os.getpid(),t_stop-t_start))


if __name__ == "__main__":
    print("当前程序（%s）开始执行" % (os.getpid()))
    t_start = time.time()
    po = Pool(3) #定义一个进程池，最大进程数3

    for i in range(9):
        #po.apply_async(worker, (i,)) ##非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程）
         po.apply(worker, (i,)) ##阻塞方式

    po.close()#关闭进程池，关闭后po不再接收新的请求
    po.join()#等待po中所有子进程执行完成，必须放在close语句之后
    t_stop = time.time()
    print("(%s)当前程序执行结束，耗时%f0.2秒" % (os.getpid(), t_stop - t_start))

阻塞方式执行结果

当前程序（7116）开始执行
0子进程（7117）开始执行,父进程是7116
(0)子进程7117执行结束，耗时0.42秒
1子进程（7118）开始执行,父进程是7116
(1)子进程7118执行结束，耗时1.17秒
2子进程（7119）开始执行,父进程是7116
(2)子进程7119执行结束，耗时0.11秒
3子进程（7117）开始执行,父进程是7116
(3)子进程7117执行结束，耗时1.52秒
4子进程（7118）开始执行,父进程是7116
(4)子进程7118执行结束，耗时0.11秒
5子进程（7119）开始执行,父进程是7116
(5)子进程7119执行结束，耗时1.40秒
6子进程（7117）开始执行,父进程是7116
(6)子进程7117执行结束，耗时1.39秒
7子进程（7118）开始执行,父进程是7116
(7)子进程7118执行结束，耗时1.18秒
8子进程（7119）开始执行,父进程是7116
(8)子进程7119执行结束，耗时1.97秒
(7116)当前程序执行结束，耗时9.4281410.2秒

非阻塞执行结果

当前程序（7201）开始执行
0子进程（7202）开始执行,父进程是7201
1子进程（7203）开始执行,父进程是7201
2子进程（7204）开始执行,父进程是7201
(2)子进程7204执行结束，耗时1.00秒
3子进程（7204）开始执行,父进程是7201
(0)子进程7202执行结束，耗时1.33秒
4子进程（7202）开始执行,父进程是7201
(4)子进程7202执行结束，耗时0.10秒
5子进程（7202）开始执行,父进程是7201
(3)子进程7204执行结束，耗时0.58秒
6子进程（7204）开始执行,父进程是7201
(1)子进程7203执行结束，耗时1.64秒
7子进程（7203）开始执行,父进程是7201
(7)子进程7203执行结束，耗时0.37秒
8子进程（7203）开始执行,父进程是7201
(5)子进程7202执行结束，耗时0.64秒
(6)子进程7204执行结束，耗时1.39秒
(8)子进程7203执行结束，耗时1.09秒
(7201)当前程序执行结束，耗时3.1433190.2秒

multiprocessing.Pool常用函数解析：

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

4、进程间通信-Queue

Process之间有时需要通信，操作系统提供了很多机制来实现进程间的通信。

4.1 Queue的使用

可以使用multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息列队程序，首先用一个小实例来演示一下Queue的工作原理：


#coding=utf-8
from multiprocessing import Queue
q=Queue(3) #初始化一个Queue对象，最多可接收三条put消息
q.put("消息1") 
q.put("消息2")
print(q.full())  #False
q.put("消息3")
print(q.full()) #True

#因为消息列队已满下面的try都会抛出异常，第一个try会等待2秒后再抛出异常，第二个Try会立刻抛出异常
try:
    q.put("消息4",True,2)
except:
    print("消息列队已满，现有消息数量:%s"%q.qsize())

try:
    q.put_nowait("消息4")
except:
    print("消息列队已满，现有消息数量:%s"%q.qsize())

#推荐的方式，先判断消息列队是否已满，再写入
if not q.full():
    q.put_nowait("消息4")

#读取消息时，先判断消息列队是否为空，再读取
if not q.empty():
    for i in range(q.qsize()):
        print(q.get_nowait())

运行结果:


False
True
消息列队已满，现有消息数量:3
消息列队已满，现有消息数量:3
消息1
消息2
消息3

说明

初始化Queue()对象时（例如：q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）；

Queue.qsize()：返回当前队列包含的消息数量；
Queue.empty()：如果队列为空，返回True，反之False ；
Queue.full()：如果队列满了，返回True,反之False；
Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True；

1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常；

2）如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常；

Queue.get_nowait()：相当Queue.get(False)；
Queue.put(item,[block[, timeout]])：将item消息写入队列，block默认值为True；

1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出"Queue.Full"异常；

2）如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常；

Queue.put_nowait(item)：相当Queue.put(item, False)；

4.2、Queue实例

我们以Queue为例，在父进程中创建两个子进程，一个往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.

4.3 进程池中的Queue

如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.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 "dongGe":
        q.put(i)

if __name__=="__main__":
    print("(%s) start"%os.getpid())
    q=Manager().Queue() #使用Manager中的Queue来初始化
    po=Pool()
    #使用阻塞模式创建进程，这样就不需要在reader中使用死循环了，可以让writer完全执行完成后，再用reader去读取
    po.apply(writer,(q,))
    po.apply(reader,(q,))
    po.close()
    po.join()
    print("(%s) End"%os.getpid())