进程池与线程池、协程、协程实现TCP服务端并发、IO模型
一、进程池与线程池
1、线程池
'''
开进程开线程都需要消耗资源，只不过两者比较的情况下线程消耗的资源比较少
在计算机能够承受范围内最大限度的利用计算机
什么是池？
在保证计算机硬件安全的情况下最大限度的利用计算机
池其实是降低了程序的运行效率，但是保证了计算机硬件的安全
（硬件的发展跟不上软件的速度）
'''
from concurrent.futures import ThreadPoolExecutor
import time
pool = ThreadPoolExecutor(5) # 括号中可以传参数，指定线程池内的线程个数，也可以不传，不传默认是当前所在计算机的CPU个数乘5
def task(n):
print(n)
time.sleep(2)
# pool.submit(task, 1) # 朝线程池中提交任务，异步提交
'''
任务的提交方式：
同步：原地等待任务的返回结果
异步：不等待任务的返回结果，直接执行下一行代码
异步的结果怎么拿？
'''
for i in range(20):
res = pool.submit(task, i) # 任务（task）的返回结果，是Future类的一个对象
print(res) # <Future at 0x31aeeb0 state=pending>,这个对象是及时生成的，所以可以立马返回，不改变异步执行
# 但是res的值是在任务执行完以后才会有
# print(res.result()) # 通过result取值，并且是原地等待结果的返回，这一行代码直接将异步执行改为了同步执行
# 如果还是想要程序异步执行，同时还能拿到任务的返回结果，就要用一个列表将res全部放进去，待任务全部提交完以后，再for循环拿出res的值
# 异步提交任务，待任务全部执行完毕后，拿到任务的返回值
from concurrent.futures import ThreadPoolExecutor
import time
def task(n):
print(n)
time.sleep(1)
return n ** 2
pool = ThreadPoolExecutor(5)
t_list = []
for i in range(20):
res = pool.submit(task, i)
t_list.append(res)
pool.shutdown() # 关闭池子，等待池子中所有的任务执行完毕后，才会往下运行代码
for t in t_list:
print('>>>>:', t.result())
2、进程池+异步回调机制
from concurrent.futures import ProcessPoolExecutor
import time
import os
pool = ProcessPoolExecutor(5)
def task(n):
print(n,os.getpid()) #获取当前进程号
time.sleep(1)
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.shutdown()
for t in t_list:
print('>>>:', t.result())
'''
异步回调机制：当异步提交的任务有返回结果之后，会自动触发回调函数的执行
根据打印出的进程号，可以发现：
池子中创建的进程创建一次就不会再创建了
至始至终用的都是最初的那几个
这样的话节省开辟进程的资源
上述结论对线程同样适用
'''
二、协程
进程：资源单位
线程：执行单位
协程：单线程下实现并发
并发：切换+保存状态
ps：看起来像是同时运行的，就可以称之为并发
协程：完全是程序员自己意淫出来的名词
单线程下实现并发
并发的条件：多道技术
空间上的复用：共用同一套操作系统
时间上的复用：切换+保存状态
程序员自己通过代码自己检测程序中的IO
一旦遇到IO自己通过代码切换
给操作系统的感觉就是你这个线程没有任何的IO
ps：欺骗操作系统，让他误以为你这个程序一直没有IO
从而保证程序在运行态和就绪态来回切换
提升代码的运行效率
切换+保存状态就一定能够提升效率吗？
当你的任务是IO密集型的情况下 提升效率
如果你的任务是计算密集型的 降低效率
极限提升CPU工作效率的方式：
多进程下开多线程
多线程下再开协程
# 串行执行 1.5458002090454102
import time
def func1():
for i in range(10000000):
i + 1
def func2():
for i in range(10000000):
i + 1
start = time.time()
func1()
func2()
stop = time.time()
print(stop - start)
# 基于yield并发执行 2.3516733646392822
# yield可以保存上一次的结果
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)
'''
需要找到一个能够识别IO的一个工具————gevent模块,这是一个第三方模块，需要我们手动下载
'''
from gevent import monkey;monkey.patch_all()
from gevent import spawn
import time
'''
注意gevent模块没办法自动识别time.sleep()等IO情况
需要你手动再配置一个参数
from gevent import monkey;monkey.patch_all()，使spawn能够监测time.sleep（）等IO
由于该模块经常使用，所以建议写成一行
'''
def heng():
print('哼')
time.sleep(2)
print('哼')
def ha():
print('哈')
time.sleep(3)
print('哈')
def heiheihei():
print('嘿嘿嘿')
time.sleep(4)
print('嘿嘿嘿')
start = time.time()
g1 = spawn(heng) # 对传入的函数名，加括号自动调用，并且监测其状态
g2 = spawn(ha)
g3 = spawn(heiheihei)
g1.join() # 等待任务运行完毕
g2.join()
g3.join()
print(time.time() - start) # 4.0027806758880615
三、通过协程实现TCP服务端并发
# 服务端
from gevent import monkey;monkey.patch_all()
from gevent import spawn
import socket
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()
# 客户端
import socket
from threading import Thread, current_thread
def client1():
client = socket.socket()
client.connect(('127.0.0.1', 8080))
n = 0
while True:
data = f'{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=client1)
t.start()