7.18python进程池

主要方法  常用的就是   from multiprocessing import Pool

map() 同步

apply() 同步

apply_async()  异步  手动 close()  join()   学的逐渐的由浅入深

# !/usr/bin/env python
# !--*--coding:utf-8 --*--
# !@Time    :2018/7/18 16:44
# !@Author   TrueNewBee

# 为什么会有进程池的概念
#   效率
#   每开启进程,开启属于这个进程的内存空间
# 寄存器 堆栈 文件
# 进程过多 操作系统的调度


# 进程池
#   python中的 先创建一个属于进程的池子
#   这个池子指定能放多少个进程
#   先将这些进程创建好


# 更高级的进程池
#   可以根据用户需求改变进程数量
# 自带join方法,里面是异步
# map(func,range) 里面传入的参数只能传入可迭代的  range ,列表,字典等
import time
from multiprocessing import Pool, Process


def func(n):
    for a in range(10):
        print(n+1)


if __name__ == ‘__main__‘:
    start = time.time()
    pool = Pool(5)                  # 5个进程
    pool.map(func, range(100))      # 100个任务  异步
    t1 = time.time() - start
    p_list = []
    for i in range(100):
        p = Process(target=func, args=(i, ))
        p_list.append(p)
        p.start()
    for i in p_list:p.join()
    t2 = time.time()-start
    print(t1, t2)

# !/usr/bin/env python
# !--*--coding:utf-8 --*--
# !@Time    :2018/7/18 20:29
# !@Author   TrueNewBee

# apply() 方法为同步的
# apply_async() 方法为异步的 一般都是用这个
import time
import os
from multiprocessing import Pool


def func(n):
    print(‘start func%s‘ % n, os.getpid())
    time.sleep(1)
    print(‘end func%s‘ % n, os.getpid())


if __name__ == ‘__main__‘:
    p = Pool(5)
    for i in range(10):
        # p.apply(func, args=(i, ))     # 该方法为同步的
        p.apply_async(func, args=(i,))  # 该方法为异步的
    # 使用apply_async 必须加的两句话
    p.close()   # 结束进程接收任务
    p.join()    # 感知进程池中的任务执行结束

# !/usr/bin/env python
# !--*--coding:utf-8 --*--
# !@Time    :2018/7/18 21:05
# !@Author   TrueNewBee

# p = Pool()
# p.map(funcName, iterable)     默认异步的执行任务,且自带close和join
# p.apply 同步调用的
# p.apply_async 异步调用 和主进程完全异步 需要手动close 和join
import time
from multiprocessing import Pool


def func(i1):
    time.sleep(0.5)
    return i1*i1


if __name__ == ‘__main__‘:
    p = Pool()
    # res_list = []   # 储存res对象 到后面一块被接收
    # for i in range(10):
    #     res = p.apply_async(func, args=(i, ))   # apply_async的结果就是func的返回值
    #     res_list.append(res)
    #     # res.get()    # get() 等着func的计算结果,阻塞了(同步)
    # for res in res_list:
    #     print(res.get())   # 每五个返回一次数据 让get()变成了异步

    # map()
    ret = p.map(func, range(100))
    print(ret)  # 整体返回所有数据

# !/usr/bin/env python
# !--*--coding:utf-8 --*--
# !@Time    :2018/7/18 21:06
# !@Author   TrueNewBee
# 回调函数
import os
from multiprocessing import Pool


def func1(n):
    print(‘in func1‘,os.getpid())
    return n*n


def func2(nn):
    print(‘in func2‘, os.getpid())
    print(nn)


if __name__ == ‘__main__‘:
    print(‘主进程:‘, os.getpid())  # 回调函数在主进程中执行的
    p = Pool(5)
    for i in range(10):
        p.apply_async(func1, args=(10, ), callback=func2)  # 回调func2返回值编程参数传给func1
    p.close()
    p.join()