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