1、进程池
硬件的发展赶不上软件的速度，电脑硬件不可能支持无线多的线程在运行（程序运行），而“池”的概念就是用来防止电脑趴窝的
保证硬件安全，最大限度利用电脑。
“池”降低了程序运行效率，保证了硬件安全（硬件的发展赶不上软件的速度）
创建线程池
python调包侠，这是 一个高阶模块
print(n.result())打印任务的返回结束
res=pool.submit(函数名，函数的参数)#提交任务的方式
#导入模块
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
#创建线程池
pool = ThreadPoolExecutor(5)#括号内可以传参数指定线程池内的线程个数。点开源码，不传，默认是当前所在计算机的cpu核心数的5倍
"""
池子中创建的进程/线程创建一次就不会再创建了
至始至终用的都是最初的那几个
这样的话节省了反复开辟进程/线程的资源
"""
def task(n):
print(n,os.getpid()) # 查看当前进程号
time.sleep(2)
return n**2
def call_back(n):
print('拿到了异步提交任务的返回结果:',n.result())
"""
提交任务的方式
同步：提交任务之后 原地等待任务的返回结果 期间不做任何事
异步：提交任务之后 不等待任务的返回结果(异步的结果怎么拿？？？) 直接执行下一行代码
异步回调机制:当异步提交的任务有返回结果之后，会自动触发回调函数的执行
"""
if __name__ == '__main__':
t_list = []
for i in range(20):
res = pool.submit(task,i).add_done_callback(call_back) # 提交任务的时候 绑定一个回调函数 一旦该任务有结果 立刻执行对于的回调函数
t_list.append(res)
证明是“异步提交”
线程池
只需改一下创建池的代码
pool = ProcessPoolExecutor() # 默认是当前计算机cpu的个数
协程（理论为主）
1“协程”完全是程序员自己意淫出的词。实现单线程下的并发！
并发：
切换+保存状态。
ps:看起来像同时执行的 就可以称之为并发
进程：资源单位
线程：执行单位
协程：单线程下实现并发
**产生并发的条件****?
多道技术:
空间上的复用(多个程序公用一套计算机硬件)
时间上的复用(切换+保存状态)
协程的概念是如何产生的?
程序员自己通过代码自己检测程序中的IO
一旦遇到IO自己通过代码切换
给操作系统的感觉是你这个线程没有任何的IO
ps:欺骗操作系统 让它误认为你这个程序一直没有IO
从而保证程序在运行态和就绪态来回切换
提升代码的运行效率
产生疑问:切换+保存状态就一定能够提升效率吗？？？
这个问题要分情况来讨论!
当你的任务是iO密集型的情况下 提升效率
如果你的任务是计算密集型的 降低效率("切换任务"是需要时间的)
产生疑问:如何保存状态?
之前"生成器"yield关键词就是用来保存上一次状态的
计算密集型串行演示(代码不需要掌握)
#**串行演示**
import time
def func1():
for i in range(10000000):
i+1
def func2():
for n in range(10000000):
n+1
start = time.time()
func1()
func2()
stop = time.time()
print(stop - start)
#时间为：1.6270930767059326秒
计算密集型基于yield并发执行(通过将两个函数体代码写在同一个for循环当中)
注意：yield并不会捕捉time.sleep()，因此他只能够保存状态，不能根据IO进行切换，因此不能做到协程。
import time
def func1():
while True:
10000000+1
yield
def func2():
g=func1()
for i in range(10000000):
# time.sleep(100) # 模拟IO，yield并不会捕捉到并自动切换
i+1
next(g)
start=time.time()
func2()
stop=time.time()
print(stop-start)
#时间为：2.5431454181671143
回顾生成器的小知识：
def func1():
while True:
10000000+1
yield
#这个函数必须func()加括号调用才是生成器
gevent模块
yeild无法识别I/O需要找到一个能够识别IO的一个工具,并且能保存状态的工具:gevent模块（该模块需要手动下载）
检测任务有无IO操作
from gevent import spawn#检测任务有无IO操作
gevent模块在使用之前也无法识别到time.sleep()等IO情况，需要手动配置一个参数
#该参数由于经常性用到，则与导入模块写成一行
from gevent import monkey;monkey.patch_all()
spawn模块如何使用?
g=spawn（要检测IO的函数名），同时点开源码，它有一个返回值,因此赋值给G。
传入函数名，它会自动加括号调用
关于切换：
切换是发生在代码层面，操作系统并不知情
代码部分：
spawn的原理：spawn相当于一个列表，spawn（）内一个放入一个列表，一个个检测，一个有io执行下一个，同时保存状态
from gevent import monkey;monkey.patch_all() # 由于该模块经常被使用 所以建议写成一行
from gevent import spawn
import time
def heng():
print("哼")
time.sleep(2)
print('哼')
def ha():
print('哈')
time.sleep(3)
print('哈')
def heiheihei():
print('嘿嘿嘿')
time.sleep(5)
print('嘿嘿嘿')
start = time.time()
g1 = spawn(heng)
g2 = spawn(ha) # spawn会检测所有的任务
g3 = spawn(heiheihei)
g1.join()
g2.join()
g3.join()
print(time.time() - start)
#时间为5.008286476135254
结论：程序员之前通过yield实现单线程的切换+保存状态高效率的使用cpu，但是他不能识别sleep等操作，使用gevent模块来弥补sleep的不足，最终实现单线程的并发！！
基于上述，让TCP服务端实现并发？
客户端：
import socket
from threading import Thread,current_thread
def client():
client = socket.socket()
client.connect(('127.0.0.1',8080))
n = 0
while True:
data = '%s %s'%(current_thread().name,n)
client.send(data.encode('utf-8'))
res = client.recv(1024)
print(res.decode('utf-8'))
n += 1
for i in range(400):
t = Thread(target=client)
t.start()
服务端：
分析：实现单线程下的并发，要用到gevent模块中的spawn，将可能出现IO操作的函数名放入里面，而服务端根据作用的不同可分为两个函数：站在门口接客的conn,addr = server.accept()，和用来收发信息的函数，同时线程需要写在main下。
将conn的函数名放入spawn括号中，再将talk函数名的spawn，卸载conn的函数内，这样做到spawn一个函数就可以同时检测两个函数的IO操作。
from gevent import monkey;monkey.patch_all()
import socket
from gevent import spawn
server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen(5)
def talk(conn):
while True:
try:
data = conn.recv(1024)
if len(data) == 0:break
print(data.decode('utf-8'))
conn.send(data.upper())
except ConnectionResetError as e:
print(e)
break
conn.close()
def server1():
while True:
conn, addr = server.accept()
spawn(talk,conn)
if __name__ == '__main__':
g1 = spawn(server1)
g1.join()
总结:
多进程下开多线程
多线程下再开协程