40 进程池回调函数线程 thrrading模块

异步的 apply_async
# 1.如果是异步的提交任务,那么任务提交之后进程池和主进程也异步了,
    #主进程不会自动等待进程池中的任务执行完毕
# 2.如果需要主进程等待,需要p.join
    # 但是join的行为是依赖close
# 3.如果这个函数是有返回值的
    # 也可以通过ret.get()来获取返回值
    # 但是如果一边提交一遍获取返回值会让程序变成同步的
    # 所以要想保留异步的效果,应该讲返回对象保存在列表里,所有任务提交完成之后再来取结果
    # 这种方式也可以去掉join,来完成主进程的阻塞

同步请求的

import os
import time
from multiprocessing import Pool
# 同步请求的
# def wahaha():
#     time.sleep(1)
#     print(os.getpid())
#     return True
#
# if __name__ == '__main__':
#     p = Pool(5)  # CPU的个数 或者 +1
#     ret_l = []
#     for i in range(20):
#        ret = p.apply(func = wahaha)   # 同步的,不用
#        print(ret)

View Code

异步请求的

ef wahaha():
    time.sleep(1)
    print(os.getpid())

if __name__ == '__main__':
    p = Pool(5)  # CPU的个数 或者 +1
    ret_l = []
    for i in range(20):
       ret = p.apply_async(func = wahaha) # async  异步的
       ret_l.append(ret)
    p.close()  # 关闭 进程池中的进程不工作了
               # 而是关闭了进程池,让任务不能再继续提交了
    p.join()   # 等待这个池中提交的任务都执行完
    # # 表示等待所有子进程中的代码都执行完 主进程才结束

View Code

# 异步提交,获取返回值,等待所有任务都执行完毕之后再统一获取结果

def wahaha():
    time.sleep(1)
    print(os.getpid())
    return True

if __name__ == '__main__':
    p = Pool(5)  # CPU的个数 或者 +1
    ret_l = []
    for i in range(20):
       ret = p.apply_async(func = wahaha) # async  异步的
       ret_l.append(ret)
    p.close()  # 关闭 进程池中的进程不工作了
               # 而是关闭了进程池,让任务不能再继续提交了
    p.join()   # 等待这个池中提交的任务都执行完
    for ret in ret_l:
        print(ret.get())

View Code

异步提交,获取返回值,一个任务执行完毕之后就可以获取到一个结果(顺序是按照提交任务的顺序)

def wahaha():
    time.sleep(1)
    print(os.getpid())
    return True

if __name__ == '__main__':
    p = Pool(5)  # CPU的个数 或者 +1
    ret_l = []
    for i in range(20):
       ret = p.apply_async(func = wahaha) # async  异步的
       ret_l.append(ret)
    for ret in ret_l:
        print(ret.get())

View Code

2 回调函数 _ 在主进程中执行

在发起任务的时候指定callback参数

在每个进程执行完apply_async任务之后,返回值会直接作为参数传递给callback的函数,执行callback函数中的代码

等待池中的任务执行完毕

import os
import time
import random
from multiprocessing import Pool
def wahaha(num):
    time.sleep(random.random())
    print('pid : ',os.getpid(),num)
    return num

def back(arg):
    print('call_back : ',os.getpid(),arg)

if __name__ == '__main__':
    print('主进程',os.getpid())
    p = Pool(5)  # CPU的个数 或者 +1
    for i in range(20):
       ret = p.apply_async(func = wahaha,args=(i,),callback=back) # async  异步的
    p.close()
    p.join()

View Code

3 进程的总结

# 进程
# 进程三状态
# 同步异步阻塞非阻塞
    # 请解释异步非阻塞
    # 给开发完成的所有装饰器+log
# 是计算机中最小的资源分配单位
# 进程的创建 Process
# 进程之间的异步本身子进程主进程之间都是异步的
# 进程之间的同步控制 Lock Semaphore Event
# 进程之间的数据隔离本身进程与进程之间都是数据隔离的
# 进程之间通信 IPC 管道队列
# 数据共享 Manager
# 进程池 -可以获取返回值
    # 同步调用 - 基本不用的
    # 异步调用 - 重要的
        # apply_async
        # get获取结果
        # close
        # join
    # 回调函数 Pool 回调函数在主进程中执行
        # apply_async(func = wahaha,callback = back)

4 线程的概念

# 进程
# 是计算机中最小的资源分配单位
# 在利用多个CPU执行的过程中,对多个程序的资源进行管理和隔离

# 进程的弊端
# 开启和关闭以及切换都会带来很大的时间开销
# 过多的进程还会造成操作系统调度的压力

# 线程
# 线程是CPU调度的最小单位
# 每个进程中至少有一个线程
# 实际上执行代码的是线程

# 线程属于进程
# 进程负责获取操作系统分配给我的资源
# 线程负责执行代码

# 从代码的角度上来看
    # 多进程
        # 开启和结束时间开销大
        # 切换的效率低
        # 内存隔离
    # 多线程
        # 开启和结束时间开销非常小
        # 切换效率高
        # 内存不隔离

# Cpython解释器下的全局解释器锁
    # 在同一个进程中的多个线程在同一时刻只能有一个线程访问CPU
    # 多线程无法形成并行
    # 锁的线程

# 什么时候才会有到CPU
# 程序计算的时候
# IO阻塞
# 是不会用到CPU的

# Jpython解释器就没有全局解释器锁
# pypy解释没有全局解释器锁

# 4cpu
# 起四个进程
# 进程里起线程

5threading 模块

import os
import time
from threading import Thread

def func():
    time.sleep(1)
    print(123,os.getpid())


print(123,os.getpid())
for  i in range(10):
    # func()
    Thread(target=func).start()

View Code

40 进程池 回调函数 线程 thrrading模块

猜你喜欢

40 进程池回调函数线程 thrrading模块