使用的包：multiprocessing
使用其中的模块：Process、Pipe、Queue、Value、Array

说明：虽然multiprocessing理论上是跨平台均可使用，但是win和linux在语法上还是有些差别！本人原始在ubuntu下运行进程间通信都很顺畅，但同样的文件在win下就通不过！原因其实很简单：win下写法要更加严格。

Process模块使用区别

在linux下的进程创建、激活以及父进程处理僵尸子进程的方式：

from multiprocessing import Process
import time

def fun(num):
    print('ceshi：', num)

pp = []
# 子进程的创建与激活
for x in range(10):
    p = Process(target = fun, args = (x,))
    pp.append(p)
    p.start()

# 以下全是父进程语句：
# 父进程处理子进程
for x in pp:
    x.join()

print('父进程处理完毕')

这是最简单的写法，但是在win下运行会报这样的错误：
The "freeze_support()" line can be omitted if the program
is not going to be frozen to produce an executable.

按照错误提示，我们只需要把主函数的语句，放到主函数里即可；因此可得win下的程序：

from multiprocessing import Process
import time

def fun(num):
    print('ceshi：', num)

if __name__ == '__main__':
    pp = []
    # 子进程的创建与激活
    for x in range(10):
        p = Process(target = fun, args = (x,))
        pp.append(p)
        p.start()

    # 以下全是父进程语句：
    # 父进程处理子进程
    for x in pp:
        x.join()

    print('父进程处理完毕')

Pipe模块使用区别

Pipe也是multiprocessing包下的一个模块，

• 作用：在内存中开辟一块管道空间来帮助多进程间进行信息传递。
• 使用：和Process模块不太一样，因为"管道"空间需要你在程序中人为声明一下，即多一条声明语句。

linux下程序：

from multiprocessing import Process,Pipe
import os,time

# 管道声明语句：必须放在最前面！！！
double1_conn, double2_conn = Pipe()

def fun1(name):
    time.sleep(1)
    double1_conn.send("ceshi" + str(name)) # 子进程往管道空间发消息
    print('父进程PID号：', os.getppid(), "；", '子进程PID号：', os.getpid())

# 子进程创建激活语句：
jobs = []
for i in range(5):
    p = Process(target = fun1, args = (i,))
    jobs.append(p)
    p.start()

# 下面全是父进程语句：
# 父进程对子进程的处理
for i in jobs:
    i.join()

# 父进程从管道空间取数据：
print('父进程从管道空间中取消息：')
for i in range(5):
    data = double2_conn.recv()
    print(data)

同样，这样的语句在win下运行还是会报和上面同样的错误！
还是提示我们要把主函数的语句下近一个主函数里：

from multiprocessing import Process,Pipe
import os,time

# 注意：传入的参数中要有一个"管道变量"！
# 因为：原本最开始的管道声明语句，现在是在fun1函数的下面！
def fun1(P, name):
    time.sleep(1)
    P.send("ceshi" + str(name))
    print('父进程PID号：', os.getppid(), "；", '子进程PID号：', os.getpid())

if __name__ == '__main__':

    double1_conn, double2_conn = Pipe()  # 管道声明语句必须放进来！

    jobs = []
    for i in range(5):
        p = Process(target = fun1, args = (double1_conn,i))
        jobs.append(p)
        p.start()

    for i in jobs:
        i.join()

    for i in range(5):
        data = double2_conn.recv()
        print(data)

注意两点：

• 管道声明必须也放进下面的主函数语句里！不能再放到文件的最前面！
• 函数传参时，必须传进去一个"管道变量(如fun1中第一个形参P)"才能在函数里发送或接受管道的信息！因为原始的管道声明语句已经放到了函数声明语句的下面。

Queue模块使用区别

另外一种进程间通信方法，使用和Pipe很像，也需要在程序中受到声明一下，在内存中开辟队列空间。

linux下程序：

from multiprocessing import Queue, Process
import time

que = Queue(10) # 队列的声明要放最前面

# 子进程的功能函数
def fun(name):
    time.sleep(1)
    que.put('ceshi' + str(name))
    print('存入一条消息', '队列中现有 %s 条消息' % que.qsize())

# 进程的创建：
jobs = []
for x in range(10):
    p = Process(target = fun, args=(x,))  
    jobs.append(p)  
    p.start()  

# 处理子进程
for x in jobs:
    x.join()

# 下面是父进程：
print('当前队列中有:', que.qsize(), '条消息')
while not que.empty():
    print('拿到的消息：', que.get(), '；', '还有 %d ' % que.qsize())

不改写的话，非常有可能会报和上面一样的错误；此外，就算有些win下可以通过，它会一直显示你没有成功得把消息传进队列当中！队列中一直只有1条消息。
因此，win下程序改写：

from multiprocessing import Queue, Process
import time

# 函数传参：必须要把绑定队列的变量传进来！
# 因为：同样声明语句已经放到了函数的下面，必须要传进来
def fun(que, name):
    time.sleep(1)
    que.put('ceshi' + str(name))
    print('存入一条消息', '队列中现有 %s 条消息' % que.qsize())

if __name__ == '__main__':

    que = Queue(10) # 队列声明必须要放进来！

    # 进程的创建：
    jobs = []
    for x in range(10):
        p = Process(target = fun, args=(que, x))
        jobs.append(p)  
        p.start() 

    # 处理子进程
    for x in jobs:
        x.join()

    # 下面是父进程：
    print('当前队列中有:', que.qsize(), '条消息')
    while not que.empty():
        print('拿到的消息：', que.get(), '；', '还有 %d ' % que.qsize())

同样注意两点：

• 队列的声明也必须放进主函数语句里，且放在其中的最前面；
• 函数传参时，必须把"绑定队列的那个变量"传进去，才能在函数里发送或提取队列的信息！因为原始的队列声明语句已经放到了函数声明语句的下面。

Value模块使用区别

• 作用：创建贡献内存，大家共同修改一个参数
• 使用：和管道差不多

linux下程序：

from multiprocessing import Value, Process
import time
import random

money = Value('i', 5000)  # 开辟共享内存，初始值给2000

# 子进程1：存钱
def deposite(money):
    for i in range(100):
        time.sleep(0.03)
        money.value += random.randint(1,150)

# 子进程2：取钱
def withdraw(money):
    for i in range(100):
        money.value -= random.randint(1,150)

# 创建子进程：
d = Process(target = deposite, args = (money,))
w = Process(target = withdraw, args = (money,))

# 激活子进程：
d.start()
w.start()

# 下面都是父进程的语句：
# 父进程处理子进程：
d.join()
w.join()

# 父进程查看最后共享内存里的那个数值：
print(money.value)

win下程序：

from multiprocessing import Value, Process
import time
import random

# 注意：传入的参数是绑定那个共享内存空间的变量！！！
# 子进程1：存钱
def deposite(money):
    for i in range(100):
        time.sleep(0.03)
        money.value += random.randint(1,150)

# 子进程2：取钱
def withdraw(money):
    for i in range(100):
        money.value -= random.randint(1,150)

if __name__ == '__main__':

    money = Value('i', 5000)  # 共享内存声明语句，必须写到里面

    # 创建子进程：
    d = Process(target = deposite, args = (money,))
    w = Process(target = withdraw, args = (money,))

    # 激活子进程：
    d.start()
    w.start()

    # 父进程处理子进程：
    d.join()
    w.join()

    # 父进程查看最后共享内存里的那个数值：
    print(money.value)

注意两点：

• 共享内存声明语句，必须写到主函数里，且在其中的最上面；
• 函数传参：传入的是绑定那个共享内存空间的变量！这个绑定的变量有自己的属性，可以获取或修改对应的共享内存中的数值。

Array模块使用区别

• 作用：共享内存创建的另一种形式，相比与value模块往共享内存中放入的是一个数值，array往共享内存中存放的是一个"元素类型必须相同"的列表。

linux下程序：

from multiprocessing import Process, Array
import time

# 声明创建一个共享内存，其中初始化一个列表
shm = Array('i', [1,2,3])

def fun(shm):
    for i in range(len(shm)):
        shm[i] = 99

# 创建子进程：
p = Process(target=fun, args=(shm,))

# 激活子进程：
p.start()

# 父进程处理子进程：
p.join()

# 父进程获取新的共享内存中数列表：
for i in shm:
    print(i)

win下的函数：

from multiprocessing import Process, Array
import time

# 修改共享内存中数组里的值
def fun(shm):
    for i in range(len(shm)):
        shm[i] = 99

if __name__ == '__main__':

    shm = Array('i', [1, 2, 3])  # 声明创建一个共享内存，要放到里面

    # 创建子进程：
    p = Process(target = fun, args = (shm,))

    # 激活子进程：
    p.start()

    # 父进程处理子进程：
    p.join()

    # 父进程获取新的共享内存中数列表：
    for i in shm:
        print(i)

注意：使用注意事项和value一样。

说明

上面所有的linux程序"不能"在win下正常运行；
但所有的win程序"可以"在linux下正常运行！！！
很明显：win下的程序写法更加正式、标准、通用！所以以后写进程间通信的程序，直接按照win要求的这种写法去写即可，只有好处没有坏处。