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()

秒客网

7.18python进程池

相关文章