Python 线程池进程池 异步回调 协程 IO模型

一 进程池与线程池

1.什么进程池和线程池：池表示一个容器，本质上就是一个存储进程或线程的列表，帮我们管理了,线程的创建；销毁；以及任务的分配。在保证计算机硬件安全的情况下最大限度的利用计算机，池其实是降低了程序的运行效率 但是保证了计算机硬件的安全(硬件的发展跟不上软件的速度)。

2.使用步骤

#1.创建池子

#2.submit 提交任务

#3.shutdown 可以用于等待所有任务完成后销毁池

进程池的使用

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time,os

# 创建进程池,指定最大进程数为3,此时不会创建进程，不指定数量时，默认为CPU核数
pool = ProcessPoolExecutor(3)

def task():
    time.sleep(1)
    print(os.getpid(),"working..")

if __name__ == '__main__':
    for i in range(10): # 开启10个任务
        pool.submit(task) # 提交任务时立即创建进程

# pool.shutdown()  # 关闭池子( 等待池子中所有的任务执行完毕之后 才会往下运行代码,相当于一阻塞)
print(1)

线程池的使用

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
from threading import current_thread,active_count
import time

# 创建进程池,指定最大线程数为3,此时不会创建线程，不指定数量时，默认为CPU和核数*5
pool = ThreadPoolExecutor(3)
print(active_count()) # 只有一个主线

def task():
    time.sleep(1)
    print(current_thread().name,"working..")

if __name__ == '__main__':
    for i in range(10):
        pool.submit(task) # 第一次提交任务时立即创建线程
    pool.shutdown() # 阻塞到所有任务完成，关闭池子

    print(2)

注意

池子中创建的进程/线程创建一次就不会再创建了
至始至终用的都是最初的那几个
这样的话节省了反复开辟进程/线程的资源

二 线程池和进程池 异步回调

1.什么是异步回调：在发起一个异步任务的同时指定一个函数，在异步任务完成时会自动的调用这个函数。

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
# 任务
def task(n):
    print(n,os.getpid())  # 查看当前进程号
    time.sleep(2)
    return n**2

# 回调函数 n 
def call_back(n):
    print('拿到了异步提交任务的返回结果:',n.result())

pool = ProcessPoolExecutor()  # 默认是当前计算机cpu的个数

if __name__ == '__main__':
    
    f =  pool.submit(task,10) # 得到的是任务结果对象future
    f.add_done_callback(call_back) # 指定回调函数，并将结果对象自动传入
    # 简便写法
    pool.submit(task,10).add_done_callback(call_back) 

总结：异步回调使用方法就是在提交任务后得到一个Futures对象，调用对象的add_done_callback来指定一个回调函数。

2.注意：

 # res = pool.submit(get_data,url).result() # 同步的方式（串行阻塞）等待任务结果 将导致所有请求任务不能并发(相当于res.result())
  

三 协程

1.什么是协程：单线程下实现并发。程序员自己通过代码自己检测程序中的IO，一旦遇到IO自己通过代码切换，给操作系统的感觉是你这个线程没有任何的IO。

ps:欺骗操作系统 让它误认为你这个程序一直没有IO，从而保证程序在运行态和就绪态来回切换，提升代码的运行效率。

2.协程有缺点：

优点：

#1. 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
#2. 单线程内就可以实现并发的效果，最大限度地利用cpu

缺点：

#1. 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程来尽可能提高效率
#2. 协程本质是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

3.使用

from gevent import monkey;monkey.patch_all()  # 由于该模块经常被使用 所以建议写成一行
from gevent import spawn
import time
"""
注意gevent模块没办法自动识别time.sleep等io情况
需要你手动再配置一个参数
"""

def task1():
    print("task1 run")
    # gevent.sleep(3)
    time.sleep(3)
    print("task1 over")

def task2():
    print("task2 run")
    # gevent.sleep(1)
    time.sleep(1)
    print("task2 over")

g1 = gevent.spawn(task1)
g2 = gevent.spawn(task2)
#gevent.joinall([g1,g2])
g1.join()
g2.join()
# 执行以上代码会发现不会输出任何消息
# 这是因为协程任务都是以异步方式提交，所以主线程会继续往下执行，而一旦执行完最后一行主线程也就结束了，
# 导致了协程任务没有来的及执行，所以这时候必须join来让主线程等待协程任务执行完毕   也就是让主线程保持存活
# 后续在使用协程时也需要保证主线程一直存活，如果主线程不会结束也就意味着不需要调用join

需要注意：

1.如果主线程结束了 协程任务也会立即结束。

2.monkey补丁的原理是把原始的阻塞方法替换为修改后的非阻塞方法，即偷梁换柱，来实现IO自动切换

必须在打补丁后再使用相应的功能，避免忘记，建议写在最上方