今日内容：
1，线程池
2，进程池
3，协程
4，IO 模型
服务端要满足这三个条件：
1,24小时不间断的提供服务
2，能够支持高并发
3，要有固定的IP地址和端口
在服务端这个地方会出现阻塞态情况：
阻塞IO 操作有：
1，链接循环
2，通信循环
单线程实现高并发思路：
为了更好的提高程序的运行效率，即实现高并发，让服务端同时能够接受多个客户端的消息
所以一般在服务端会把，连接循环和通信循环封装为两个不同的函数方法，
这样当一个客户端与服务端进行通信时，服务端的连接循环可以和其他客户端进行连接，
不要等待，从而提高了效率，可以利用单线程来完成高并发，即来一个客户端就开一个线程，
每来一个客户端就开一个线程，看上去像高并发！
案列：
import socket
from threading import Thread
def server1():
server = socket.socket()
server.bind(('127.0.0.1', 1688))
server.listen(5)
server2(server)
def task(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 server2(server): 连接循环
while True:
conn, addr = server.accept() # 在这里会形成阻塞，监听是否有客户端过来
t = Thread(target=task, args=(conn,))
t.start()
问题：上面的案例虽然解决了线程高并发的问题，但是但有大量的客户端来访问服务端时，由于开启线程也是需要消耗资源的
所以但有几亿个用户同时访问时，也架不住量大，也会造成内存溢出，服务器奔溃现象，这是由于硬件性能决定的，
所以为了防止服务器奔溃，保证数据的安全性，在保证计算机能够承受的范围内，最大限度的利用计算机，
就引入了池这个概念
1，什么是池？
在保证计算机硬件安全的情况下最大限度的利用计算机
池其实是降低了程序的运行效率 但是保证了计算机硬件的安全
(硬件的发展跟不上软件的速度)
2，线程池，
进程池
案列：
import time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
# 线程池，在你不传参数的情况下，默认的是当前计算机CPU的个数*5
pool = ThreadPoolExecutor(5) # 括号内可以传参数，指定线程池的线程个数
# 只要创建了五个线程，就永远是这五个线程，这五个线程并不会动态创建，动态销毁
# 好处是节省空间，进程也是如此
def task(n):
print(n)
time.sleep(2)
#return n*2
t_list = []
for i in range(20):
res = pool.submit(task,i) # submit 的返回值是一个内部Future类产生的对象
print(res) # 类对象 res.result()它拿到的结果就是task任务的返回值
print(res.result()) # 结果为 0 None 1 None 2 None 3 None...19 None
1,将结果变为串行 2，结果为None （在这里res.result()拿到得是task这个任务的返回结果
原地等待任务的返回结果 ，即同步，如果这样调就会将并发变为串行
结果为None，是因为task任务的返回结果为None，所以为空，如果加上return n*2，那就不为空
t_list.append(res)
pool.shutdown() # 1，关闭池子，即20个线程提交完毕，立马关闭池子，就像关门打狗一样
# 2，等待池子里面所有的任务完成之后才会继续向下执行
for p in t_list:
print('>>>>>对象',p.result(),p)
# 结果是乱的：14
# >>>>>对象 None <Future at 0x2aa9829a5f8 state=finished returned NoneType>
如果加上pool.shutdown()，就是等任务全部结束，才会走pool.shutdown() 下面的代码，
3，进程池
from concurrent.futures import ProcessPoolExecutor
pool = ProcessPoolExecutor(5) #进程池不传参数，默认当前CPU的个数
#异步回调机制:当异步提交的任务有返回结果之后，会自动触发回调函数的执行
4，协程：
1，什么是协程：单线程下实现并发 只是一个名称，即表示一个效果
进程：正在运行的程序，资源单位
线程：cpu最小的执行单位
并发：看起来像同时进行，就可以称之为并发，即切换+保存状态
并行：真正的同时进行，单核情况下无法并行
多道技术：1，空间上的复用 即 多个程序利用一台计算机
2，时间上的复用 切换+保存状态
切换的状态：1，程序遇到IO操作，就会进行切换
2，长时间的占用CPU 时，时间片用完，也会切换
程序员自己通过代码自己检测程序中的IO
一旦遇到IO自己通过代码切换
给操作系统的感觉是你这个线程没有任何的IO
ps:欺骗操作系统 让它误认为你这个程序一直没有IO
从而保证程序在运行态和就绪态来回切换
提升代码的运行效率
gevent模块
import time
from gevent import monkey;monkey.patch_all() #固定写法
from gevent import spawn
# 注意gevent模块没办法自动识别time.sleep()等io情况
# 需要你手动在配置一个参数，自动检测io，遇到io就开始切换
def heng():
print('哼22')
time.sleep(1)
print('哈哈哈我')
def ao():
print('嗷嗷')
time.sleep(3)
print('收拾一下')
start = time.time() # 在这里注意spawn()是有返回值的，返回值是一个类的对象
g1 = spawn(heng) # spawn ，相当于一个列表，先来一个heng添加到列表中，后面再来一个ao在添加到列表中
g2 = spawn(ao) # 一旦heng遇到IO 就执行ao，一旦ao遇到IO就立即执行heng，就是不断来回切换
g1.join() # 等待任务完成，不然就不会执行此任务，而是走主线程，主线程没代码，程序直接结束
g2.join() # 在右键运行后，spawn就在这两个任务之间来回疯狂的切，这个切换是在代码层面的切
# 来欺骗操作系统，让操作系统误认为没有遇到IO
# heng() # 串行执行
# ao() # 串行执行 这样执行的结果是5秒多
print(time.time()- start) # spawn(heng) spawn(ao)执行的结果
5，IO模型
数据交互，要的数据都在内存，是互相把数据发到对方的内存
1，阻塞IO
先系统要数据，没有数据时，阻塞+等待数据，一旦有数据来了
进行数据的拷贝，拷贝到数据在回复ok，中间等待和拷贝的过程都是阻塞IO
2, 非阻塞IO
程序处于运行态和就绪态，向内存要数据，没有数据也会立马给你返回一个结果
一直反复的要，一直反复的回，直到有数据真的来了，就会进行拷贝，此时会形成阻塞
这就是非阻塞io
3, 异步IO
异步进行，异步提交任务后，立即给你一消息，但是内部在等待，等到内部有数据是立马
返回给你，进行下一步操作
4, IO多路复用
就是 select，相当于一个检测机制，像一个列表，统一管理，要什么数据select去负责跟
内存要数据，由他负责，不用你管，有了之后回来给你，然后再执行以下操作，相当于餐厅服务员