python 进程池

一、概念

进程池，在进程池中有5(自定义)个进程，有n个任务等待进入进程池，一次只能进入5个任务

优点：节省了n-5个进程的内存空间，n个进程的创建时间

信号量：一次只允许固定的进程进行操作，进程的内存空间和创建时间都没减少，只减轻了操作系统的压力

二、常用方法

close()方法

　　作用：进程池禁止任务进入

　　格式：obj.close()

join()方法的

　　作用：感知进程池的任务结束

　　格式：obj.join()

三、map()方法

特点：异步，自带close()方法和join()方法

格式：map(函数名, 可迭代对象)

import time
from multiprocessing import Pool


def test(n):
    n = n + 1
    time.sleep(0.5)
    print(n)


if __name__ == '__main__':
    p = Pool(5)     # 进程池中有5个任务
    p.map(test, range(30))      # 参数是0-29,执行30个任务，是异步执行，打印的结果不是按顺序执行

from multiprocessing import Pool
import time


def str_add(s):
    new_s = s + '_sb'
    time.sleep(0.5)
    print(new_s)


if __name__ == '__main__':
    p = Pool(3)     # 进程池3个进程
    p.map(str_add, ['joker', 'mark', 'peter', 'hacker', 'richard'])     # 5个任务, 异步

from multiprocessing import Pool
import time
import random


def str_add(s):
    new_s = s + '**'
    time.sleep(random.randrange(1, 3))
    print(new_s)


if __name__ == '__main__':
    p = Pool(3)     # 进程池3个进程
    p.map(str_add, 'hello_world')     # 5个任务, 异步

四、apply()

特点：同步

格式：obj.apply(函数名, args=tuple)

from multiprocessing import Pool
import time


def str_add(s):
    new_s = s + '**'
    time.sleep(0.5)
    print(new_s)


if __name__ == '__main__':
    p = Pool(3)     # 进程池3个进程
    for i in range(3):
        p.apply(str_add, args=('cv%s' % i,))    # 同步，结果一个接着一个打印

五、apply_async

特点：异步，需要close()和join()方法

格式：obj.apply_async(函数名, args=tuple)

from multiprocessing import Pool
import time


def str_add(s):
    new_s = s + '**'
    time.sleep(0.5)
    print(new_s)


if __name__ == '__main__':
    p = Pool(3)     # 进程池3个进程
    for i in range(10):
        p.apply_async(str_add, args=('cv%s' % i,))    # 异步，结果一个接着一个打印
    p.close()   # 结束进程池接收任务
    p.join()    # 感知进程池中的任务执行结束

六、返回值

1、map()

"""
map()方法自带close()方法和join()方法
所有的进程都执行完毕后，赋值给ret
"""
from multiprocessing import Pool
import time


def mun_mul(n):
    time.sleep(0.5)
    return n*n


if __name__ == '__main__':
    p = Pool(3)     # 进程池3个进程
    ret = p.map(mun_mul, range(10))
    print(ret)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

2、apply

"""
apply()，进程同步，一个一个打印返回值
"""
from multiprocessing import Pool
import time


def mun_mul(n):
    time.sleep(0.5)
    return n*n


if __name__ == '__main__':
    p = Pool(3)     # 进程池3个进程
    for i in range(10):
        ret = p.apply(mun_mul, args=(i, ))  # 同步
        print(ret)  

"""
apply_async()是异步，但打印的数据是一个接着一个
原因：get()方法
"""
from multiprocessing import Pool
import time


def mun_mul(n):
    time.sleep(0.5)
    return n*n


if __name__ == '__main__':
    p = Pool(3)     # 进程池3个进程
    for i in range(10):
        ret = p.apply_async(mun_mul, args=(i, ))  # 异步
        # print(ret)  # 结果是对象
        print(ret.get())

from multiprocessing import Pool
import time


def mun_mul(n):
    time.sleep(0.7)
    return n*n


if __name__ == '__main__':
    p = Pool(4)     # 进程池3个进程
    ret_li = []
    for i in range(10):
        ret = p.apply_async(mun_mul, args=(i, ))  # 异步
        ret_li.append(ret)
        # print(ret)  # 结果是对象
    for o in ret_li:
        print(o.get())

七、回调函数

"""
回调函数：callback=函数名
函数名的参数，是func的返回值
回到的进程是主进程
"""
from multiprocessing import Pool
import os
import time


def mun_mul(n):
    time.sleep(0.7)
    print('1  ---- %s' % os.getppid())
    return 2 * n


def test2(m):
    print('2  ---- %s' % os.getppid())
    print(m*2)


if __name__ == '__main__':
    p = Pool(4)     # 进程池3个进程
    print('3  ---- %s' % os.getppid())
    ret_li = []
    for i in range(10):
        p.apply_async(mun_mul, args=(i, ), callback=test2)  # 异步
    p.close()
    p.join()