进程池与线程池
开进程和开线程都需要消耗资源,只不过两者比较的情况线程消耗的资源比进程要少
在计算机能够承受范围之内最大限度的利用计算机
什么是池?
- 在保证计算机硬件安全的情况下最大限度的利用计算机
- 池其实是降低了程序的运行效率,但是保证了计算机的硬件的安全(硬件的发展跟不上软件的发展速度)
线程池
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time
import os
pool = ThreadPoolExecutor(5) # 括号内可以传参数指定线程内的线程个数,也可以不传,不传默认是当前所在计算机的cpu个数乘5
pool = ProcessPoolExecutor(5)
def task(n):
print(n)
time.sleep(2)
return n**2
t_list = []
for i in range(20):
res = pool.submit(task,1) # 朝线程池中提交任务,异步提交
print(res.result()) # 原地等待任务的返回结果,将并发变为串行
t_list.append()
pool.shutdown() # 关闭池子,等待池子中所有的任务执行完毕后,才会往下运行代码
for p in t_list:
print('>>>:',p.result())
进程池
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time
pool = ProcessPoolExecutor() # 不传值时默认是当前计算机cpu的个数
def task(n):
print(n,os.getpid()) # 查看当前进程号
time.sleep(2)
return n**2
if __name__ == '__main__':
t_list = []
for i in range(20):
res = pool.submit(task,1) # 朝线程池中提交任务,异步提交
print(res.result()) # 原地等待任务的返回结果,将并发变为串行
t_list.append()
pool.shutdown() # 关闭池子,等待池子中所有的任务执行完毕后,才会往下运行代码
for p in t_list:
print('>>>:',p.result())
总结:
- 池子中创建的进程/线程,创建一次就不会再创建了,至始至终都是用的最初的那几个,这样做节省了反复开辟进程/线程的资源
异步回调机制:当异步提交的任务有返回结果时,会自动触发回调函数的执行
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time
pool = ProcessPoolExecutor(5)
def task(n):
print(n,os.getpid()) # 查看当前进程号
time.sleep(2)
return n**2
def callback(n):
print('拿到了异步提交任务的返回结果:',n)
if __name__ == '__main__':
t_list = []
for i in range(20):
res = pool.submit(task,1).add_done_callback(call_back) # 提交任务时,绑定一个回调函数,一旦任务有结果,立刻执行对应的回调函数
t_list.append(res)
提交任务的方式:
- 同步:提交任务后,原地等待任务的返回结果,期间不做任何事
- 异步:提交任务后,不等待任务的返回结果(异步的结果怎么拿),直接执行下一行代码
协程
进程:资源单位
线程:执行单位
协程:
- 单线程下实现并发
- 完全是程序员自己意淫出来的名词
- 并发:切换+保存状态
- PS:看起来像同时执行的,就可以称之为并发
实现并发的条件
- 多道技术
- 空间上的复用
- 时间上的复用
- 切换+保存状态
实现原理:
- 程序员自己通过代码检测程序中的IO,一旦遇到IO,自己通过代码切换,给操作系统的感觉时你这个线程没有任何的IO
- PS:欺骗操作系统,让它误认为你这个程序一直没有IO,从而保证程序在运行态和就绪态来回切换,提升代码的运行效率
切换+保存状态就一定能够提升效率吗?
- 当你的任务就io密集型的情况下,则提升效率
- 如果你的任务是计算密集型的,则降低效率
注意:yield保存上一次的结果
# 基于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模块)
注意:gevent模块无法自动识别time.sleep等IO情况,需要手动再配置一个参数(monkey.patch_all())
from gevent import monkey;monkey.patch_all() # 由于该模块经常被使用,所以建议写成一行
from gevent import spawn
import time
def heng():
print('哼')
time.slepp(2)
print('哼')
def ha():
print('哈')
time.sleep(3)
print('哈')
start = time.time()
g1 = spawn(heng)
g2 = spawn(ha) # spawn会监测所有的任务
g1.join()
g2.join()
print(time.time() - start)
'''
哼
哈
3.002878...秒
'''
总结:
- 多进程下开多线程
- 多线程下再开协程
TCP单线程实现并发
客户端
import socket
from Thread 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()
服务端
import socket
from gevent import monkey;monkey.patch_all()行
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 ConnectResetError as e:
print(e)
break
conn.close()
def server_run():
while True:
conn,addr = server.accept()
spawn(talk,conn)
if __name__ == '__main__':
g1 = spawn(server_run)
g1.join()