码迷,mamicode.com
首页 > 编程语言 > 详细

5,线程池,进程池,协程,IO模型

时间:2019-08-15 23:13:24      阅读:178      评论:0      收藏:0      [点我收藏+]

标签:硬件安全   int   set   io多路复用   lis   条件判断   try   识别   BMI   

今日内容:
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去负责跟
内存要数据,由他负责,不用你管,有了之后回来给你,然后再执行以下操作,相当于餐厅服务员

5,线程池,进程池,协程,IO模型

标签:硬件安全   int   set   io多路复用   lis   条件判断   try   识别   BMI   

原文地址:https://www.cnblogs.com/Fzhiyuan/p/11360955.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!