socketserver = 多进程 + 多线程 + IO模型
一、上节课复习及作业讲解
a、spawn用法复习
from gevent import monkey,spawn;monkey.patch_all()
import time
def f1():
print('from f1 1')
time.sleep(3) # 直接调用gevent模块实现遇到IO切换+保持状态
print('from f1 2')
def f2():
print('from f2 1')
time.sleep(2)
print('from f2 2')
def f3():
print('from f3 1')
time.sleep(5)
print('from f3 2')
g1=spawn(f1)
g2=spawn(f2)
g3=spawn(f3)
# time.sleep(10) # spawn 默认为异步调用,如果不加time.sleep或 g.join(),spawn提交后不在原地等待执行, 程序直接结束
g1.join()
g2.join()
g3.join()
b、作业讲解
服务端:
from gevent import monkey,spawn;monkey.patch_all()
from threading import Thread
from socket import *
def talk(conn):
while True:
try:
data=conn.recv(1024)
if not data:break
conn.send(data.upper())
except ConnectionResetError:
break
conn.close()
def server(ip,port,backlog=5):
s = socket()
s.bind((ip,port))
s.listen(backlog)
while True:
conn, addr = s.accept()
print(addr)
# 通信
g=spawn(talk,conn)
s.close()
if __name__ == '__main__':
spawn(server,'127.0.0.1',8080).join() # spawn 默认为异步调用,如果不加time.sleep或 g.join(),spawn提交后不在原地等待执行, 程序直接结束
# server('127.0.0.1',8080) # 效果等用于spawn(server,'127.0.0.1',8080).join()
客户端:
from threading import Thread,current_thread
from socket import *
import os
def client():
client = socket()
client.connect(('127.0.0.1', 8080))
while True:
data = '%s hello' % current_thread().name
client.send(data.encode('utf-8'))
res = client.recv(1024)
print(res.decode('utf-8'))
if __name__ == '__main__':
for i in range(1000): #开启1000个线程,以提高效率
t=Thread(target=client)
t.start()
二、网络IO操作之wait data和copy data
网路IO的两个阶段(copy data阶段 + wait data阶段),换言之,所有IO都围绕这两个阶段
服务端:
from socket import *
s = socket() # 等同于s=socket(AF_INET, SOCK_STREAM) 默认AF_INET 及 SOCK_STREAM
s.bind(('127.0.0.1',8080))
s.listen(5)
while True:
conn, addr = s.accept() # wait data (wait的时间取决于客户端和网络两方面因素)+ copy data(app <=> kernel);accept可感觉到明显的阻塞
print(addr)
while True:
try:
data = conn.recv(1024) # wait data + copy data(app <=> kernel) ;recv可感觉到明显的阻塞
if not data: break # for linux, do not pop ConnectionResetError
print('from client msg: ',data)
except ConnectionResetError: # for windows
break
conn.close()
客户端:
from socket import *
client = socket() # s=socket(AF_INET, SOCK_STREAM) 默认AF_INET 及 SOCK_STREAM
client.connect(('127.0.0.1', 8080))
while True:
data = input('>>: ').strip()
if not data:continue # if just enter, ask to re-input
client.send(data.encode('utf-8')) # copy data(app <=> kernel) only
#send(只有copy data阶段)是IO操作,但有时可能感觉不到明显的阻塞,一是因为传输的数据量少,二是因为是本地copy操作不经历网络过程;但如果send的数据量特别大,是有可能感受到阻塞的。
print('has send')
讲IO模型的目的:自己实现gevent模块,解决单线程下的IO问题(网络IO,不含time.sleep),从而得到高性能。(之前讲的多进程和多线程并没有解决IO)
三、阻塞IO模型
wait data和copy data阶段一个都不能少,完完整整的等下来即为阻塞IO模型
之前所接触的多进程、多线程、进程池、线程池(除了gevent模块以外)都是阻塞IO模型。
四、非阻塞IO模型(更好的利用wait data阶段)
非阻塞IO只能监测网络IO,不监测time.sleep()这种IO
非阻塞IO有可能大规模占用CPU做无用操作,所以不推荐使用非阻塞IO
a、 非阻塞IO模型(基础bug版)
服务端:
from socket import *
import time
s = socket()
s.bind(('127.0.0.1',8080))
s.listen(5)
s.setblocking(False) # 不设置默认是True;将其设置成False,即将所有阻塞编程非阻塞(遇到等不到数据的情况,不阻塞,会抛出信息:BlockingIOError)
#gevent模块中 monkey.patch_all() 即 s.setblocking(False)
r_list=[]
while True:
try:
conn, addr = s.accept()
r_list.append(conn)
except BlockingIOError:
# time.sleep(3) # 非阻塞IO即完全没有阻塞,不应该人为加入time.sleep()
print('可以去干其他的活了')
print('rlist: ',len(r_list))
for conn in r_list:
try:
data=conn.recv(1024)
conn.send(data.upper())
except BlockingIOError: #如果等不到数据,报出的错误为BlockingIOError
continue
客户端:
from socket import *
import os
client = socket()
client.connect(('127.0.0.1', 8080))
while True:
data='%s say hello' %os.getpid()
client.send(data.encode('utf-8'))
res=client.recv(1024)
print(res.decode('utf-8'))
b、 非阻塞IO模型(修正)
服务端:
from socket import *
import time
s = socket()
s.bind(('127.0.0.1',8080))
s.listen(5)
s.setblocking(False)
r_list=[]
w_list=[]
while True:
try:
conn, addr = s.accept()
r_list.append(conn)
except BlockingIOError:
# time.sleep(0.05) #非阻塞模型不应该加time.sleep(); 加上time.sleep(0.05) 即把非阻塞IO模型变成IO多路复用模型
print('可以去干其他的活了')
print('rlist: ',len(r_list))
# 收消息
del_rlist=[]
for conn in r_list:
try:
data=conn.recv(1024)
if not data: # for linux,不抛出ConnectionResetError,监测是否收到数据
conn.close()
del_rlist.append(conn)
continue
# conn.send(data.upper()) # 错误做法: send亦有可能阻塞,所以不推荐放在这个位置,宜分到下面发消息模块独立完成
w_list.append((conn,data.upper())) # 正确做法: 收集待send数据信息; 以小元组的形式写入列表
except BlockingIOError:
continue
except ConnectionResetError:
conn.close()
# r_list.remove(conn) # 错误做法: 在循环期间不推荐改变所循环对象(list,dict等)的结构
del_rlist.append(conn) # 正确做法: 在循环期间不推荐改变所循环对象(list,dict等)的结构
# 发消息
del_wlist=[]
for item in w_list:
try:
conn=item[0] # 将小元组中数据依次取出
res=item[1] # 将小元组中数据依次取出
conn.send(res)
del_wlist.append(item)
except BlockingIOError:
continue
except ConnectionResetError:
conn.close()
del_wlist.append(item)
# 回收无用连接
for conn in del_rlist:
r_list.remove(conn) # 正确做法: 在循环期间不推荐改变所循环对象(list,dict等)的结构
for item in del_wlist:
w_list.remove(item)
客户端:
from socket import *
import os
client = socket()
client.connect(('127.0.0.1', 8080))
while True:
data='%s say hello' %os.getpid()
client.send(data.encode('utf-8'))
res=client.recv(1024)
print(res.decode('utf-8'))
五、IO多路复用
IO多路复用可同时监测多个套接字,循环询问操作系统是否已准备好数据。在之前修正版的非阻塞IO模型中加入time.sleep() 即将非阻塞IO模型转化成IO多路复用模型
当只监测一个套接字时,多路复用比阻塞IO的效率还要低。
一般会使用select模块帮忙完成IO多路复用模型。(注意: select不能监测到ConnectionResetError,只能监测到BlockingIOError)
服务端:
from socket import *
import select
s = socket()
s.bind(('127.0.0.1',8080))
s.listen(5)
s.setblocking(False)
# print(s)
r_list=[s,]
w_list=[]
w_data={}
while True:
print('被检测r_list: ',len(r_list))
print('被检测w_list: ',len(w_list))
rl,wl,xl=select.select(r_list,w_list,[],) #r_list=[server,conn] rl等存放等到数据的对象
# print('rl: ',len(rl)) #rl=[conn,]
# print('wl: ',len(wl))
# 收消息
for r in rl: #r=conn
if r == s: #r l为已经有等到信息的对象,可能为s,亦可为conn;当为s时,执行accept,当为conn时,执行recv
conn,addr=r.accept()
r_list.append(conn) # 建立好连接后,将连接丢入r_list中监测
else:
try:
data=r.recv(1024)
if not data: # select模块不帮忙捕捉ConnectionResetError,此操作针对linux系统
r.close()
r_list.remove(r)
continue
# r.send(data.upper())
w_list.append(r)
w_data[r]=data.upper()
except ConnectionResetError: #select模块不帮忙捕捉ConnectionResetError,此操作针对windows系统
r.close()
r_list.remove(r)
continue
# 发消息
for w in wl:
w.send(w_data[w])
w_list.remove(w)
w_data.pop(w)
客户端:
from socket import *
import os
client = socket()
client.connect(('127.0.0.1', 8080))
while True:
data='%s say hello' %os.getpid()
client.send(data.encode('utf-8'))
res=client.recv(1024)
print(res.decode('utf-8'))
六、异步IO模型
异步IO模型的效率最高
之前设计到的异步调用+回调即用到了异步IO模型。具体的实现操作会在爬虫中详细介绍
from concurrent.futures import ThreadPoolExecutor
from threading import current_thread
import time
import os
def task(n):
print('%s is running' %current_thread().name)
time.sleep(2)
return n**2
def parse(obj):
res=obj.result()
print(res)
if __name__ == '__main__':
t=ThreadPoolExecutor(4)
future1=t.submit(task,1)
future1.add_done_callback(parse) #parse函数会在future1对应的任务执行完毕后自动执行,会把future1自动传给parse
future2=t.submit(task,2)
future2.add_done_callback(parse)
future3=t.submit(task,3)
future3.add_done_callback(parse)
future4=t.submit(task,4)
future4.add_done_callback(parse)
七、重点知识归纳(网络编程+ 并发编程)
一 网络编程
目标:编写一个C/S或B/S架构的基于网络通信的软件
1、C/S,B/S(*****)
server<===============>client
服务端特点:
1、不间断地提供服务
2、服务端要支持并发+高性能
2、互联网
互联网=物理连接介质+互联网协议(OSI七层***)
tcp三次握手,四次挥手 (*****)
tcp可靠,但不如udp效率高 (*****)
udp不可靠,但效率高 (*****)
3、socket(*****)
socket抽象层位于传输层与应用层之间
4、基于tcp协议的套接字通信(*****)
加上连接循环
加上通信循环
5、粘包问题:(*****)
tcp流式协议独有的粘包问题
解决方法:自定义报头
udp数据报协议没有粘包问题
6、远程执行命令的小程序/上传下载文件的程序(*****)
7、基于udp协议的套接字通信(***)
二 并发编程
目标:让服务端能够支持高并发+高性能
1、 操作系统发展史
多道技术(*****)
产生背景
多道技术的核心:
1、空间上的复用
2、时间上的复用
*****
并发:看起来同时运行
并行:真正意义上的同时运行,一个cpu同一时刻只能做一件事
只有多核才能同时做多件事,即并行的效果
2、进程
1、进程理论(*****)
2、开启进程的两种方式(*****)
3、守护进程(**)
4、互斥锁与信号量(**)
5、IPC机制:队列,管道(*)
6、进程queue=管道+锁 (***)
7、生产者消费者模型(*****)
3、线程
1、线程理论(*****)
2、开启线程的两种方式(*****)
3、守护线程(**)
4、互斥锁与信号量(**)
5、GIL vs 互斥锁(*****)
6、Cpython的解释器下(*****)
多个任务是IO密集型:多线程
多个任务是计算密集型:多进程
7、死锁现象与递归锁(**)
8、线程queue(***)
9、Event事件(**)
4、池(*****)
为何要用池:
操作系统无法无限开启进程或线程
池作用是将进程或线程控制操作系统可承受的范围内
什么时候用池:
当并发的任务数要远超过操作系统所能承受的进程数或
线程数的情况应该使用池对进程数或线程数加以限制
如何用池?
池内装的东西有两种:
装进程:进程池
装线程:线程池
进程线程池的使用
提交的两种方式:
同步调用
异步调用+回调机制
任务执行的三种状态:
阻塞
阻塞
非阻塞:
就绪
运行
5、单线程下实现并发(****)
协程:在应用程序级别实现多个任务之间切换+保存状态
高性能:
单纯地切换,或者说么有遇到io操作也切换,反而会降低效率
检测单线程下的IO行为,实现遇到IO立即切换到其他任务执行
gevent
6、IO模型(主要掌握理论****)
阻塞IO
非阻塞IO
IO多路复用
异步IO