python多进程的理解，多进程读写公共数据，多进程并行，

1. 多进程读写公共数据，多进程并行

import multiprocessing, os, time  
import numpy as np

#公共数据
temp = np.zeros((4,12))
# 回调函数，用于多进程读写公共数据的，我的理解：多进程在回调函数这里是串行的，否则同时读写会乱掉
# 回调函数必须只有一个输入参数
def mycallback(index):
    i,j = index[0],index[1]
    temp[i,j] = i+j
# 多进程处理的耗时的算法函数
def multiprocess(i,j):
    print("子进程开始执行>>> pid={},ppid={},编号{}".format(os.getpid(), os.getppid(), i))
    time.sleep(2)
    return (i,j)
if __name__ == '__main__':
    time_start = time.time()
    MultiP = multiprocessing.Pool(2)  # 多进程

    for i in range(3):

        for j in range(4):
            print("主进程开始执行>>> parent_pid={}".format(os.getpid()))
            MultiP.apply_async(multiprocess, args=(i, j,), callback=mycallback)

    # 关闭进程池，停止接受其它进程
    MultiP.close()
    # 阻塞进程 等待进程池中的所有进程执行完毕，必须在close()之后调用
    MultiP.join()
    print("主进程终止")
    time_end = time.time()
    print('totally cost', time_end - time_start)
    print(temp)

到这里你应该懂了怎么用python多进程读写公共数据，下面对比几种多进程写法，深入理解进程池
2.python多进程的理解

import multiprocessing, os, time  # 多进程 from multiprocessing import Pool,cpu_count
import numpy as np

'''
多进程示例程序，多个进程并行，共同读写：temp
'''
temp = np.zeros((4,12))

def mycallback(index):
    i,j = index[0],index[1]
    temp[i,j] = i+j


def multiprocess(i,j):
    print("子进程开始执行>>> pid={},ppid={},编号{}".format(os.getpid(), os.getppid(), i))
    time.sleep(2)
    return (i,j)

def test1():
    '''
    相当于 一次性 把4个活全部分配给2个进程，等这4个活 干完了 ，再陆续分配3次
    注意：MultiP.join() 即要求把一次性分配的活干完了，才能分配下次
    :return:
    '''
    time_start = time.time()

    for i in range(3):
        MultiP = multiprocessing.Pool(2)  # 多进程
        for j in range(4):
            print("主进程开始执行>>> parent_pid={}".format(os.getpid()))
            MultiP.apply_async(multiprocess, args=(i, j,), callback=mycallback)

        # 关闭进程池，停止接受其它进程
        MultiP.close()
        # 阻塞进程 等待进程池中的所有进程执行完毕，必须在close()之后调用
        MultiP.join()

    print("主进程终止")
    time_end = time.time()
    print('totally cost', time_end - time_start)
    print(temp)

def test2():
    '''
    速度比test1快，比test3慢
    一次性分配3*4个活给 2 个进程，直到干完，如果每个进程干活速度差不多，则每个进程运行6次，即每个进程的PID出现6次
    理解：一共有6个工人（电脑cpu总数目），有12包货物，4个人旁观，2个人在搬，不休息，直到搬完，所以这2个人一共搬了6次。
    :return:
    '''
    time_start = time.time()
    MultiP = multiprocessing.Pool(2)  # 多进程
    for i in range(3):

        for j in range(4):
            print("主进程开始执行>>> parent_pid={}".format(os.getpid()))
            MultiP.apply_async(multiprocess, args=(i, j,), callback=mycallback)

    # 关闭进程池，停止接受其它进程
    MultiP.close()
    # 阻塞进程 等待进程池中的所有进程执行完毕，必须在close()之后调用
    MultiP.join()

    print("主进程终止")
    time_end = time.time()
    print('totally cost', time_end - time_start)
    print(temp)

def test3():
    '''
    这种是最快的，但是不清楚原因
    一次性分配3*4个活给 2 个进程，直到干完。区别在于每次有2个进程去领活，但是每次进程的PID不一样
    理解：一共有6个工人（电脑cpu总数目），有12包货物，每次有2人去搬，搬完2包后这俩人休息了，然后另外2人去搬，这样轮流，则每个人搬2次
    :return:
    '''
    time_start = time.time()
    for i in range(3):
        MultiP = multiprocessing.Pool(2)  # 多进程
        for j in range(4):
            print("主进程开始执行>>> parent_pid={}".format(os.getpid()))
            MultiP.apply_async(multiprocess, args=(i, j,), callback=mycallback)

    # 关闭进程池，停止接受其它进程
    MultiP.close()
    # 阻塞进程 等待进程池中的所有进程执行完毕，必须在close()之后调用
    MultiP.join()

    print("主进程终止")
    time_end = time.time()
    print('totally cost', time_end - time_start)
    print(temp)

if __name__ == '__main__':
    test1()
    test2()
    test3()

3、报错：DLL 文本过长
采用test3()可能会报错： 文本过长，这个时候你采用test2()方式就不会报错了。这个和电脑“内存”的大小有关系