Python【Windows】进程池

multiprocessing.Pool

from multiprocessing import Pool
# 执行函数
def func(i):
    from time import sleep
    print('i')
    sleep(1)
    print(i)
    sleep(1)
# 多进程
def mult(func, n):
    # 1.创建进程池,放入适量进程
    pool = Pool(processes=n)
    # 2、将事件加入进程池，进程池自动地处理事件
    for i in range(n):
        pool.apply_async(func, (i,))
    # 3、关闭进程池接口
    pool.close()
    # 4、主程序阻塞等待，所有事件完成后，回收进程池
    pool.join()
# 运行
if __name__ == '__main__':
    mult(func, 4)

multiprocessing.Process

from multiprocessing import Process
# 执行函数
def func(i):
    from time import sleep
    print(i)
    sleep(1)
    print('i')
    sleep(1)
# 多进程
def mult(funct, step):
    pool = []  # 进程池
    for offset in range(step):
        p = Process(target=funct, args=(offset,))
        pool.append(p)
    for p in pool:
        p.start()
    for p in pool:
        p.join()
# 运行
if __name__ == '__main__':
    mult(func, 4)

共享内存

共享数值

from multiprocessing import Pool, Manager
from time import sleep

def f(share, i):
    sleep(i)
    share.value += i
    print('step%d:' % i, share)

def mult():
    share = Manager().Value('d', 0)
    functions = [f, f, f, f]
    pool = Pool(processes=len(functions))
    for i in range(len(functions)):
        pool.apply_async(functions[i], (share, i))
    pool.close()
    pool.join()
    print('final:', share)

if __name__ == '__main__':
    mult()

共享数组

from multiprocessing import Pool, Manager
from time import sleep

def f1(share, i):
    sleep(i)
    print('step%d:' % i, share)
    share[i] = 3 - i

def f2(share, i):
    sleep(i)
    print('step%d:' % i, share)
    share[i] = 3 - i

def f3(share, i):
    sleep(i)
    print('step%d:' % i, share)
    share[i] = 3 - i

def mult():
    share = Manager().Array('d', [0, 0, 0])
    functions = [f1, f2, f3]
    pool = Pool(processes=3)
    for i in range(3):
        pool.apply_async(functions[i], (share, i))
    pool.close()
    pool.join()
    print('final:', share)

if __name__ == '__main__':
    mult()

比较Pool、Process、Thread

def multiprocess(functions):
    from multiprocessing import Pool
    pool = Pool(processes=len(functions))
    for f in functions:
        pool.apply_async(f)
    pool.close()
    pool.join()

def multiprocess(functions):
    from multiprocessing import Process
    pool = [Process(target=f) for f in functions]
    for p in pool:
        p.start()
    for p in pool:
        p.join()

def multithreading(functions):
    from threading import Thread
    pool = [Thread(target=f) for f in functions]
    for p in pool:
        p.start()
    for p in pool:
        p.join()

def ff():
    print(1)
    from time import sleep
    sleep(1)
    print(2)

multithreading([ff, ff])

• Pool跳过错误且不打印任何东西，而Process报错
• lambda放入多进程会出错
• Windows下使用多进程要加if __name__ == '__main__'