多线程的使用场景
上次讲了由于GIL锁的存在,Python的多线程是假的,用的还是CPU的单核。Python的多线程只是利用了CPU的上下文切换,上下分切换也是占用CPU的。那么什么时候用多行程?
Python的多线程,适合IO密集型的任务,不适合CPU密集型的任务。
IO操作不占用CPU,比如socket这种网络编程的情景。
计算占用CPU,所以大量计算的情景下多线程反而更慢,额外消耗了CPU切换上下文的计算。
多进程
多进程的基本语法和多线程差不多:
import multiprocessing
import time
def show(name):
time.sleep(2)
print('hello', name)
if __name__ == '__main__':
p = multiprocessing.Process(target=show, args=('Jack',))
p.start()
p.join() # join的效果就是等待子进程执行完毕
print('执行结束')
上面的例子,只模块名变了,其他都和多线程差不多。
父进程和子进程的id号
下面的例子打印了进程的id号:
import multiprocessing
import os, time
def info(title):
print(title, 'module name:', __name__) # 模块名
time.sleep(0.3) # 加点停顿,可以看出来,所有进程真的是并行处理的
print(title, 'parent process:', os.getppid()) # 父进程号
time.sleep(0.3)
print(title, 'process id:', os.getpid()) # 进程号
def f(title):
info(title)
if __name__ == '__main__':
info('main')
for i in range(10): # 这次起10个进程
p = multiprocessing.Process(target=f, args=('p%s' % i,))
p.start()
可以适当修改加长info的延时,,可以去系统里查看一下所有进程的情况,如下图:
上面起了10个子进程,加上主进程,一个11个python进程。
我是用pycharm执行的代码,主进程的ID是8036,主进程的父进程是pycharm7832。
然后,所有的子进程,都是通过8036这个python的父进程开启的。8036就是这些子进程的父进程。
进程间通讯
进程间的内存是独立的,如果进程间需要交换数据,就需要借助其他方法
通过队列 - Queue
下面的例子通过Queue实现了进程间的通信,
from multiprocessing import Process, Queue
import time
def f(q):
q.put([42, None, 'hello'])
time.sleep(30)
if __name__ == '__main__':
q = Queue()
p = Process(target=f, args=(q,))
p.start()
print(q.get()) # prints "[42, None, 'hello']"
time.sleep(30)
这里的Queue是 multiprocessing 多线程模块里的,不是之前的独立的queue模块。
通过管道 - Pipe
from multiprocessing import Process, Pipe
def f(conn):
conn.send([42, None, 'hello'])
conn.close()
if __name__ == '__main__':
parent_conn, child_conn = Pipe() # 实例化管道后会生成2个对象,这2个对象是一样的
p = Process(target=f, args=(child_conn,)) # 把管道的1头交给子进程,自己操作另外一头
p.start()
print(parent_conn.recv()) # prints "[42, None, 'hello']"
上面实例化管道之后的两个对象是一样的,不要被名字误导,这么取名是随进程的关系。
实例化后的两个对象就是管道的两头。通讯的双方任意各取一头操作,就能实现管道两头的通讯。这里是父进程留下一头,把另一头传递给子进程操作。
这里管道的操作使用send和recv,类似socket(不过没有黏包)。这边send一次对端就recv一次获取数据,如果一边send多次,那么对端也只能一次recv取到一次的数据,所以也得recv多次才能取到全部的数据。如果数据取完了,再recv则会阻塞,等待管道对端send数据进来。
通过 Manager 共享
上面的2个方法,只是实现了数据的传递。
通过Manager生成的数据对象,可以在多个进程间共享。以下的数据类型都可以通过Manager来生成,实现共享:
list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array
举例说明:
from multiprocessing import Process, Manager
import os
def f(d, l):
pid = os.getpid()
d['pid'] = pid # 每次这个key都会被重写,最后打印的一定是最后一个操作的进程的结果
d[pid] = pid # 每次都是生成一个新的key,添加到字典里
l.append(pid) # 每次往列表中添加一个元素
if __name__ == '__main__':
with Manager() as manager: # 等于manager = Manager(),最后还省了一个manager.close()
d = manager.dict() # 生成一个共享的字典
l = manager.list() # 生成一个共享的列表
p_list = []
for i in range(10):
p = Process(target=f, args=(d, l))
p.start()
p_list.append(p)
for res in p_list:
res.join()
print(d)
print(l)
进程锁 Lock
线程有线程锁,进程也有进程锁。用法也和线程锁一样,如下:
from multiprocessing import Process, Lock
import time
def f(l, n):
l.acquire()
print('hello world', n, end='', flush=True)
time.sleep(0.1)
print(" Finished", n)
l.release()
time.sleep(0.1)
if __name__ == '__main__':
lock = Lock()
for n in range(10):
Process(target=f, args=(lock, n)).start()
有锁,但是我们要锁什么?上面的代码就算不加锁应该也不一定会有什么问题。线程锁我们锁的是内存,因为线程共享的是同一块内存空间。进程锁锁的是资源,进程就是各种资源的集合。比如例子中的print用到的就是屏幕输出的资源,如果不加锁,可能几个进程同时想操作屏幕输出内容,那么就有可能会造成最终输出的字符错乱。不过打印数据应该是一串一次性进缓存的,应该也不会出现被插队吧。
虽然试不出字符错乱的情况,但是对两次print之间不要插入别的进程的内容。比如例子中去掉进程锁就会出现两段内容混乱的情况。
和线程锁的情况一样,加了锁之后,其实就应该是暂时变成了串行执行了。
进程池
每起一个进程,就是克隆一份父进程的基本数据给子进程用。这样开销会很大(比如内存),系统资源是有限的,无限起进程,可能会导致系统瘫痪。所以要有进程池。
学习线程的时候也有类似的问题,不过线程占用资源小,不容易导致系统瘫痪,但是一定会导致CPU频繁切换上下文导致效率反而会降低。所以要有信号量。
设定进程池,可以限制一次起的进程的数量。这点有点像信号量
进程池有两个方法:
- apply :还是串行
- apply_async :这个是并行
apply
先看apply的例子:
from multiprocessing import Pool
import time
def Foo(i):
time.sleep(1)
print("In Foo", i)
if __name__ == '__main__':
pool = Pool(5)
for i in range(10):
pool.apply(func=Foo, args=(i,))
print('end')
pool.close() # 老师说进程池这里要先close再join,至于为啥不知道
pool.join() # 进程池中进程执行完毕后再关闭,如果注释,那么程序直接关闭。
执行的时候就是同时起5个进程(Pool中设置了进程池的大小),但是是一个一个依次执行的。执行完毕后会退出然后可以将之后的进程放入进程池等待执行。
注意最后要先close再join。可以试验一下,如果不执行close,但是直接执行join的话会报错。
apply_rsync
使用这个方法就是并行效果了,一次并行执行5个。每完成1个会再将下一个放入进程池马上执行:
from multiprocessing import Pool
import time
def Foo(i):
time.sleep(1)
print("In Foo", i)
if __name__ == '__main__':
pool = Pool(5)
for i in range(10):
pool.apply_async(func=Foo, args=(i,))
print('end')
pool.close()
pool.join() # 进程池中进程执行完毕后再关闭,如果注释,那么程序直接关闭。
注意:还是close和join的问题,刚才异步的时候其实不写也没问题。但是这里由于是并行的,主进程执行完毕之后如果没有join就会直接关闭了。子进程也不会再执行了,就像守护线程那样。所以这里一定要加上join,等待pool里的进程都执行完毕。然后join前必须要close。
回调函数
callback参数 :这里还有一个callback参数,函数执行完成后可以调用另一个函数,这个叫回调函数。
回调函数 :就是前面的方法执行完之后,就会自动对用执行这个回调函数。并且是由主进程调用执行的。
举例说明:
from multiprocessing import Pool
import os
import time
def Foo(i):
time.sleep(1)
# raise
return os.getpid(), os.getppid()
def Bar(arg):
print(os.getpid(), 'Foo 执行完毕,结果:', arg)
if __name__ == '__main__':
pool = Pool(5)
for i in range(10):
pool.apply_async(func=Foo, args=(i,), callback=Bar)
print('end')
pool.close()
pool.join() # 进程池中进程执行完毕后再关闭,如果注释,那么程序直接关闭。
回调函数只有在函数正常执行完之后才会被调用。Foo中有一句raise,主动抛出一个错误,如果去掉注释导致函数没有正常执行完成,rais之前的print还是会正常执行,但是不会调用callback的函数执行。
另外,这里打印了每个进程id,从id中可以看到,Foo函数是由主进程启动的子进程执行的。而callback的函数是由主进程来执行的。Foo的父进程id就是Bar的进程id
回调函数的意义,主要就是因为回调函数是由主进程执行的。如果子进程的执行结果需要记录保留,那么这部分工作就通过调用回调函数,由回调函数在主进程中来处理。比如将结果写入数据库,我们就要让每个子进程都连接数据库写入数据,而是在主进程里建立一个与数据库的连接,统一将执行结果写入数据库。虽然调用的是同一个函数,但是通过回调函数调用在主进程中执行效率会更高。比如例子中的做法,Foo负责返回数据,回调函数统一打印Foo的执行结果。
协程
协程,又称微线程,纤程。英文名Coroutine。一句话说明:协程是一种用户态的轻量级线程。
协程的好处:
- 无需线程上下文切换的开销:就是没有CPU层面的上下文切换参考多线程的实现,我们在代码中实现切换
- 无需原子操作锁定及同步的开销:就是不用加线程锁
- 方便切换控制流,简化编程模型
- 高并发+高扩展性+低成本:一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。
所谓原子操作是指不会被线程调度机制打断的操作;这种操作一旦开始,就一直运行到结束,中间不会有任何
协程的缺点:
- 无法利用多核资源:协程的本质是个单线程,它不能同时将CPU 的多个核用上
- 进行阻塞(Blocking)操作(如IO时)会阻塞掉整个程序
之前学习生成器的时候,通过yield实现了单线程下多并发。但是那也不是真正的协程。
协程的定义:
- 必须在只有一个单线程里实现并发
- 修改共享数据不需加锁
- 用户程序里自己保存多个控制流的上下文栈
- 一个协程遇到IO操作自动切换到其它协程
总结:使用协程就是为了高效。协程如何实现高效?一遇到IO操作就切换,因为IO操作耗时但是不占用CPU,此时切换到另一个协程,高效的利用CPU。
问题:何时切换回来?IO操作结束了就可以切换回来。如何知道IO操作结束了?往下学 ...
yield
这里写个例子,回顾一下yield的用法。但是yield并不满足我们前面对协程的定义。
下面的例子会先启动B,B会启动A。B中打印后切换到A执行,A返回后循环。A中打印后通过yield返回,循环。A和B之间通过yield和send来传递count的值,每次都自增1。
import time
def print_A():
count = 0
while True:
print('A'.center(9, '-'), count)
time.sleep(0.1)
count = yield count+1 # 从B那里send过来的值,赋值给count。然后回到开头执行打印,把count值自增1后再返回给B
def print_B(func):
count = next(func) # 要先next一下,启动A,这样A会先运行一次到yield的地方返回
while True:
print('B'.center(9, '-'), count)
time.sleep(0.1)
count = func.send(count+1) # 将值传递给A的yield,并获取A的返回值
if __name__ == '__main__':
a = print_A()
print_B(a)
greenlet 模块
greenlet是一个用C实现的协程模块,相比与python自带的yield,它可以使你在任意函数之间随意切换,而不需把这个函数先声明为generator。
这个是第三方模块,所以需要安装。安装的话直接安装下面要讲的gevent模块就好了。
greenlet 模块实现的是协程的手动切换,其实就和yield差不多。不过用起来更好理解了。
gevent 模块才能实现我们要的自动切换,但是gevent是在greenlet的基础上进行了封装,实现了自动切换。所以安装的时候顺便把有依赖关系的greenlet模块一起装好了。现在自然也是先看一下greenlet模块的用法。
from greenlet import greenlet
def test1():
print('A1')
gr2.switch()
print('A2')
gr2.switch()
def test2():
print("B1")
gr1.switch()
print('B2')
if __name__ == '__main__':
gr1 = greenlet(test1) # 启动一个协程
gr2 = greenlet(test2) # 再启动一个协程
gr1.switch() # 手动切换一下
执行一下switch,就完成了切换的操作。比yield更直观。不过重点是学下一个模块。
gevent 模块
Gevent 是一个第三方库,可以轻松通过gevent实现并发同步或异步编程,在gevent中用到的主要模式是Greenlet,它是以C扩展模块形式接入Python的轻量级协程。Greenlet全部运行在主程序操作系统进程的内部,但它们被协作式地调度。
import gevent
def func1():
print("This is in func1")
gevent.sleep(2)
print("End of func1")
def func2():
print("This is in func2")
gevent.sleep(1)
print("End of func2")
if __name__ == '__main__':
gevent.joinall([gevent.spawn(func1),
gevent.spawn(func2)])
# 上面是把要启动的方法加到列表里一起处理了,推荐就这么做
# 其实也可以使用start和join一个一个启动,
f1 = gevent.spawn(func1)
f2 = gevent.spawn(func2)
f1.start() # 没有start,貌似也一样,注释掉试一下
f2.start()
f1.join() # 没有join主线程会直接退出,就不会等待上面的协程的执行结果了
f2.join()
要启动所有的协程,通过gevent.joinall。参数是一个列表,列表中依次启动需要进行自动切换操作的协程。并且阻塞等待所有协程处理完毕。相当于start和join
上面的gevent.sleep是一个模拟IO操作,不会像time.sleep那样停在那里,而是会当做有一个几秒的IO操作。上面的输出结果是:
This is in func1
This is in func2
End of func2
End of func1
首先执行了func1,打印了第一行。然后之后是一个IO操作,所以切换到了下一个协程。
切换到func2,打印了一行,之后又是一个IO操作,此时再切换。不过此时已经没有可操作的协程了。没别的协程了,fun1也没好。
之后是fun2的IO操作先执行完毕,所以最终切换到fun2的时候,打印了func2的第二行,打印前会顿1秒。
最后func1的IO操作也结束了,于是切换到fun1,打印fun1的第二行,打印前会再顿1秒。
并发爬网页
这根本就不是爬虫,这里先讲如何将一个网页保存到本地,因为这就是一个比较耗时的IO操作。刚才的例子中我们是用sleep来模拟的。直接上代码就好了:
from urllib import request
def f(url):
print('GET: %s' % url)
resp = request.urlopen(url) # 给网址发一个请求
data = resp.read() # 读取到的就是整个网页的内容
with open('url.html', 'wb') as file: # 将网页保存下来
file.write(data)
print('%d betes received from %s' % (len(data), url))
if __name__ == '__main__':
f('http://www.python.org/')
然后我们来多爬几个网页,看下协程的效果。这次计算一下整个过程的时间:
from urllib import request
import gevent
import time
def f(url):
print('GET: %s' % url)
resp = request.urlopen(url) # 给网址发一个请求
data = resp.read() # 读取到的就是整个网页的内容
# with open('url.html', 'wb') as file: # 保存网页的操作就先不用了
# file.write(data)
print('%d betes received from %s' % (len(data), url))
if __name__ == '__main__':
g_list = []
url_list = ['http://www.python.org/', 'http://www.yahoo.com/', 'http://github.com/']
for url in url_list:
g_list.append(gevent.spawn(f, url))
start_time = time.time()
gevent.joinall(g_list)
print('运行时间:', time.time()-start_time)
上面这段虽然用了gevent,但是还是串行的。到底是串行还是并行,只要看f函数开始的时候的第一句print是什么时候出现的就知道了。这里之所以是串行,是因为,并没有看到IO切换的命令,就是f函数里没有类似gevent.sleep这样的切换命令。但是,其实gevent是可以自动判断是否有IO操作的。所以这里的问题是gevent发现不了urllib模块里的IO操作。
所以真正要做的是在开头加上一句,让gevent能够发现这些IO操作。
from urllib import request
import gevent
import time
# 导入模块,添加下面这2句
from gevent import monkey
monkey.patch_all() # 把当前程序的所有的IO操作给我单独的做上标记
def f(url):
print('GET: %s' % url)
resp = request.urlopen(url) # 给网址发一个请求
data = resp.read() # 读取到的就是整个网页的内容
# with open('url.html', 'wb') as file: # 保存网页的操作就先不用了
# file.write(data)
print('%d betes received from %s' % (len(data), url))
if __name__ == '__main__':
g_list = []
url_list = ['http://www.python.org/', 'http://www.yahoo.com/', 'http://github.com/']
for url in url_list:
g_list.append(gevent.spawn(f, url))
start_time = time.time()
gevent.joinall(g_list)
print('运行时间:', time.time()-start_time)
高并发的socket_server
gevent里有专门的socket模块,当然其中大部分都是import原生的socket模块。我们可以使用gevent的socket实现一个单线程下高并发的socket_server。
服务端:
# 就算这里不导入socket,也会在gevent模块里导入。但是pycharm里下面的socket.socket会显示个错误,不影响运行
# 而且到下面也是要导入的,这里显示的声明一下,提前导入也不会影响效率
# import socket # 建议导入
# 下面两句也可以不要,这里不加也能识别到socket的IO操作
# 只所以能识别,是因为下面的socket已经不是原生的socket了,而是gevent修改后的socket
# from gevent import monkey
# monkey.patch_all()
import gevent
from gevent import socket
def server(port):
# 这里pycharm里会显示个错误,不影响运行。因为gevent的socket模块里没有socket这个方法
# 但是其实gevent会把原生的socket全部导入的。就是运行的时候会有socket.socket这个方法
server = socket.socket()
server.bind(('localhost', port))
server.listen(500)
print("监听已经开始")
while True:
conn, addr = server.accept()
print("发现连接请求:\n%s\n%s" % (conn, addr))
gevent.spawn(handle_request, conn)
# 上面的函数建立了连接后,就将连接作为handle_request的参数,启动一个gevent的协程
# 下面的方法是通过协程启动的,是协程并发运行的
def handle_request(conn):
while True:
data = conn.recv(1024)
if not data: break
print("recv:", data.decode('utf-8'))
conn.send(data.upper())
conn.close()
print("断开连接:", conn)
if __name__ == '__main__':
server(8002)
客户端只需要之前的客户端就可以了。这里测试一下效率,起100个线程,每个线程发送100条消息:
import socket
import threading
HOST = 'localhost' # The remote host
PORT = 8002 # The same port as used by the server
def client(i):
client = socket.socket()
client.connect((HOST, PORT))
for j in range(100):
msg = "hello %s %s" % (i, j)
client.send(msg.encode('utf-8'))
data = client.recv(1024)
print('Received:', data.decode('utf-8'))
client.close()
if __name__ == '__main__':
for i in range(100):
t = threading.Thread(target=client, args=(i,))
t.start()
这里有一个问题,记一下。 gevent.spawn()
事件驱动与异步IO
通常,我们写服务器处理模型的程序时,有以下几种模型:
- 每收到一个请求,创建一个新的进程,来处理该请求
- 每收到一个请求,创建一个新的线程,来处理该请求
- 每收到一个请求,放入一个事件列表,让主进程通过非阻塞I/O方式来处理请求。就是协程
三种方法各有千秋,之前应该都说过,这里就当总结一下:
- 进程,由于创建新的进程的开销比较大,所以,会导致服务器性能比较差,但实现比较简单。
- 线程,由于要涉及到线程的同步,有可能会面临死锁等问题。
- 协程,在写应用程序代码时,逻辑比前面两种都复杂。
事件驱动模型,目前大部分的UI编程都是事件驱动模型,如很多UI平台都会提供onClick()事件(比如web页面),这个事件就代表鼠标按下事件。事件驱动模型大体思路如下:
- 有一个事件(消息)队列
- 鼠标按下时,往这个队列中增加一个点击事件(消息)
- 有个循环,不断从队列取出事件,根据不同的事件,调用不同的函数,如onClick()、onKeyDown()等
- 事件(消息)一般都各自保存各自的处理函数指针,这样,每个消息都有独立的处理函数
事件驱动编程范式
事件驱动编程是一种编程范式,这里程序的执行流由外部事件来决定。它的特点是包含一个事件循环,当外部事件发生时使用回调机制来触发相应的处理。另外两种常见的编程范式是(单线程)同步以及多线程编程。
在面对如下的环境时,事件驱动模型通常是一个好的选择:
- 程序中有许多任务
- 任务之间高度独立(因此它们不需要互相通信,或者等待彼此)
- 在等待事件到来时,某些任务会阻塞
此处重申一下协程开篇提出的问题,只要一遇到IO就注册一个事件,然后主程序就可以继续干其它的事情了,直到IO处理完毕后,继续恢复之前中断的任务,这本质上是怎么实现的呢?
五种IO模式
用户空间与内核空间:现在操作系统都是采用虚拟存储器,那么对32位操作系统而言,它的寻址空间(虚拟存储空间)为4G(2的32次方)。操作系统的核心是内核,独立于普通的应用程序,可以访问受保护的内存空间,也有访问底层硬件设备的所有权限。为了保证用户进程不能直接操作内核(kernel),保证内核的安全,操作系统将虚拟空间划分为两部分,一部分为内核空间,一部分为用户空间。针对linux操作系统而言,将最高的1G字节(从虚拟地址0xC0000000到0xFFFFFFFF),供内核使用,称为内核空间,而将较低的3G字节(从虚拟地址0x00000000到0xBFFFFFFF),供各个进程使用,称为用户空间。
缓存 I/O :又被称作标准 I/O,大多数文件系统的默认 I/O 操作都是缓存 I/O。在 Linux 的缓存 I/O 机制中,操作系统会将 I/O 的数据缓存在文件系统的页缓存( page cache )中,也就是说,数据会先被拷贝到操作系统内核的缓冲区中,然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。
IO模式
对于一次IO访问(以read举例),数据会先被拷贝到操作系统内核的缓冲区中,然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。所以说,当一个read操作发生时,它会经历两个阶段:
- 等待数据准备 (Waiting for the data to be ready)
- 将数据从内核拷贝到进程中 (Copying the data from the kernel to the process)
正是因为上面的两个阶段,linux系统产生了下面五种网络模式的方案:
- 阻塞 I/O(blocking IO) :就是最最简单的串行,效率低实现简单
- 非阻塞 I/O(nonblocking IO) :第一阶段不会阻塞,需要反复主动发起询问数据是否准备好,第二阶段会阻塞
- I/O 多路复用( IO multiplexing) :还是完全的阻塞,没什么优越性,但是可以同时处理多个连接。后面详讲
- 信号驱动 I/O( signal driven IO) :略过没讲,第一阶段不阻塞,等待告知数据已经准备好,第二阶段会阻塞
- 异步 I/O(asynchronous IO) :完全没有阻塞,看似是最好的方式。但是用的不多。asyncio模块在python3.4引入标准库,支持异步IO
五种模型的比较:
用的最多的是IO多路复用。虽然看似异步IO更好,反正用的不多。另外多线程+阻塞模式也是一个方案,但是多线程的开销较大(相对于单线程),更适合处理少量的并发(多少算少?看你系统能起多少个线程,不过和进程比线程的开销还不算特别大)。要处理高并发,推荐还是使用IO多路复用。
IO多路复用
文件描述符(File descriptor) :是计算机科学中的一个术语,是一个用于表述指向文件的引用的抽象化概念。文件描述符在形式上是一个非负整数。实际上,它是一个索引值,指向内核为每一个进程所维护的该进程打开文件的记录表。当程序打开一个现有文件或者创建一个新文件时,内核向进程返回一个文件描述符。在程序设计中,一些涉及底层的程序编写往往会围绕着文件描述符展开。但是文件描述符这一概念往往只适用于UNIX、Linux这样的操作系统。
I/O多路复用就是通过一种机制,一个进程可以监视多个描述符,一旦某个描述符就绪(一般是读就绪或者写就绪),就通知程序进行相应的读写操作。
IO多路复用的三种机制:
select :最早出现,有些缺点,优势就是几乎在所有平台上都支持。
pool :解决了部分缺点,但是本质上没多大差别,可以认为是个过度阶段。
epool :现在用这个,性能最好的。但是不是所有系统都支持,windows就不支持。
写一个非阻塞的socket
Python的select()方法直接调用操作系统的IO接口,它监控sockets,open files,and pipes(所有带fileno()方法的文件句柄)何时变成readable 和writeable,或者通信错误,select()使得同时监控多个连接变的简单,并且这比写一个长循环来等待和监控多客户端连接要高效,因为select直接通过操作系统提供的C的网络接口进行操作,而不是通过Python的解释器。
写一个socket的例子来理解
注意:socket必须得运行在非阻塞模式下。之前用的都是默认的阻塞模式,阻塞模式下,如果没有数据会等待。非阻塞模式下,如果没有数据就会抛出异常。所以我们需要用select来帮我们监视
开启监听
先写到accept之前,accept之前只是设置,执行到accept在阻塞模式下会进入阻塞。我们暂时只要能收到客户端请求建立起连接就好。现在是阻塞模式,所以直接accept没有数据就会报错。所以就需要select来解决了,监视到有活动的连接再返回并继续执行accept。
import select
import socket
server = socket.socket()
server.bind(('localhost', 9000))
server.listen()
print("监听已经开启")
server.setblocking(False) # 设置为非阻塞
inputs = [server, ]
outputs = []
# 3个参数,读列表,写列表,异常列表,就是你想让内核监视哪些链接
# 异常列表监视的还是链接返回的内容,那么还是在inputs里,所以第三个参数还是填inputs
# 开始什么都没有,只有server,先把server加到inputs里
# 就是select监视到server活动了,就可以返回了
# 返回3个数据,监视到有活动的3个列表(读列表,写列表,异常列表)
readable, writeable, exceptional = select.select(inputs, outputs, inputs)
# 这里就是阻塞的,直到select监视到列表中有活动的链接,才会继续
# 非阻塞socket就是通过select来实现阻塞
print(readable, writeable, exceptional) # 下面有打印的内容
# [<socket.socket fd=472, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000)>] [] []
# 第一个fd,就是文件描述符,非负整数。
conn, addr = server.accept()
print(conn, addr)
测试的客户端,只发不收:
import socket
HOST, PORT = "localhost", 9000
client = socket.socket()
client.connect((HOST, PORT))
while True:
msg = input(">>:").strip()
if len(msg) == 0: break
client.send(msg.encode('utf-8'))
# 下面2行是接收服务的返回是要用的,暂时先注释掉,到后面再启用测试返回数据
# data = client.recv(1024)
# print('Received:', data.decode('utf-8'))
client.close()
接收一条数据
上面链接已经可以建立起来了,那么来接收一条数据吧。这里recv之前当然还是要用select来监视是否有数据进来,有才会执行到recv。
import select
import socket
server = socket.socket()
server.bind(('localhost', 9000))
server.listen()
print("监听已经开启")
server.setblocking(False) # 设置为非阻塞
inputs = [server, ]
outputs = []
# 3个参数,读列表,写列表,异常列表,就是你想让内核监视哪些链接
# 异常列表监视的还是链接返回的内容,那么还是在inputs里,所以第三个参数还是填inputs
# 如果inputs里是读的消息,会返回到readable列表里,如果是异常消息,就返回到exceptional列表里
# 开始什么都没有,只有server,先把server加到inputs里
# 就是select监视到server活动了,就可以返回了
# 返回3个数据,监视到活动的3个列表(读列表,写列表,异常列表)
readable, writeable, exceptional = select.select(inputs, outputs, inputs)
# 这里就是阻塞的,直到select监视到列表中有活动的链接,才会继续
# 非阻塞socket就是通过select来实现阻塞
print(readable, writeable, exceptional) # 打印一下监视到的活动链接
for r in readable: # 可能一次返回多个连接啊,所以得写个循环
conn, addr = server.accept() # 已经是非阻塞了,不经过select监视就会报错。可以注释掉select试一下
print(conn, addr)
inputs.append(conn) # 把链接加入监视列表
# 现在conn加到了inputs的监视列表里了,就可以通过select监视conn是否有数据进来了
readable, writeable, exceptional = select.select(inputs, outputs, inputs)
print(readable, writeable, exceptional) # 看看打印内容,inputs里的活动链接是conn,其实也可能是server
data = conn.recv(1024)
print(data.decode('utf-8'))
这里可以再试一下,应该可以接收到数据。但是这里有个问题。因为现在inputs列表里监视的内容是2个了,一个是server,一个是conn。如果再监视到server活动,说明又有新链接进来,如果监视到的是conn的活动,那么才是收到数据了。所以我们要在for循环里判断收到的活动链接是谁的。
可以接收多个连接请求
再多做一步,加上一层while循环,让服务端始终处于这么一个循环之中:select返回活动链接 ==> for循环处理所有的活动链接 循环继续。
import select
import socket
server = socket.socket()
server.bind(('localhost', 9000))
server.listen()
print("监听已经开启")
server.setblocking(False) # 设置为非阻塞
inputs = [server, ]
outputs = []
# 3个参数,读列表,写列表,异常列表,就是你想让内核监视哪些链接
# 异常列表监视的还是链接返回的内容,那么还是在inputs里,所以第三个参数还是填inputs
# 开始什么都没有,只有server,先把server加到inputs里
# 就是select监视到server活动了,就可以返回了
# 返回3个数据,监视到活动的3个列表(读列表,写列表,异常列表)
while True: # select返回活动链接==>for循环处理所有的活动链接,循环往复
readable, writeable, exceptional = select.select(inputs, outputs, inputs)
# 这里就是阻塞的,直到select监视到列表中有活动的链接,才会继续
# 非阻塞socket就是通过select来实现阻塞
print(readable, writeable, exceptional) # 下面有打印的内容
# [<socket.socket fd=472, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000)>] [] []
# 第一个fd,就是文件描述符,非负整数。
for r in readable: # 可能一次返回多个连接啊,所以得写个循环
# 现在inputs里有server 和 conn了,
# 如果readable返回的是server的活动,表示来了一个新链接
# 如果readable返回的是conn的活动,表示收到了conn发来的数据
if r is server:
conn, addr = server.accept() # 已经是非阻塞了,不经过select监视就会报错。可以注释掉select试一下
print(conn, addr)
inputs.append(conn) # 把链接加入监视列表
else:
data = conn.recv(1024)
print(data.decode('utf-8'))
现在新链接也能再连上来了,但是问题是旧的连接没有另外保存,最新连上的链接会再次赋值给conn。就链接发来的数据,导致select返回,但是会用conn去尝试recv。现在conn是新的连接,所以是空的,于是就报错。那么解决这个事情就是要保存每一个conn,就是说要再用一个列表保存所有的conn,再写一个for循环?我一开始是这么想的。
其实所有的连接都保存在inputs里了,for循环的时候就是取出每一个链接,在for循环里面应该使用变量r,而不是conn。难怪之前用conn的时候,pycharm会提示 ‘name can not be defined’ 。第一次循环的时候没有conn这个变量,不过也不会进到那个if里
将收到的数据发回给客户端
接下来继续,我们可以直接把数据发回去,这里没有阻塞的问题,就不搞了。换个方法,不直接发回去,先把消息保存到队列里。然后统一发送,这样就是发消息也是多路复用的形式。
import select
import socket
import queue
server = socket.socket()
server.bind(('localhost', 9000))
server.listen()
print("监听已经开启")
server.setblocking(False) # 设置为非阻塞
inputs = [server, ]
outputs = []
data_queue = {} # 存放返回给客户端消息的队列,每个客户端连接一个队列,就是一个item
# 3个参数,读列表,写列表,异常列表,就是你想让内核监视哪些链接
# 异常列表监视的还是链接返回的内容,那么还是在inputs里,所以第三个参数还是填inputs
# 开始什么都没有,只有server,先把server加到inputs里
# 就是select监视到server活动了,就可以返回了
# 返回3个数据,监视到活动的3个列表(读列表,写列表,异常列表)
while True: # select返回活动链接==>for循环处理所有的活动链接,循环往复
readable, writeable, exceptional = select.select(inputs, outputs, inputs)
# 这里就是阻塞的,直到select监视到列表中有活动的链接,才会继续
# 非阻塞socket就是通过select来实现阻塞
print('select返回:\n', readable, writeable, exceptional) # 下面有打印的内容
# [<socket.socket fd=472, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000)>] [] []
# 第一个fd,就是文件描述符,非负整数。
for r in readable: # 可能一次返回多个连接啊,所以得写个循环
# 现在inputs里有server 和 conn了,
# 如果readable返回的是server的活动,表示来了一个新链接
# 如果readable返回的是conn的活动,表示收到了conn发来的数据
if r is server:
conn, addr = r.accept() # r就是server
print('接收到新的客户端连接:\n', conn, addr)
inputs.append(conn)
data_queue[conn] = queue.Queue() # 创建连接的消息队列
else:
data = r.recv(1024) # r就是conn
print(data.decode('utf-8'))
# 接下来处理发数据
# 把有数据返回的连接当道outputs列表里,这样下次循环select就会监视到
# 要发的数据也得保存,这里用队列来保存准备发送的数据
# 要为每个连接分别建一个队列,不能把消息搞混,这里用字典
# 字典的key就是连接,value就是该连接的消息队列
outputs.append(r)
# data_queue = {} 在使用前,要先建立一个空字典。这句放到While循环外
# data_queue[conn] = queue.Queue # 在客户端建立连接时,就创建好连接的消息队列。这句放在上面处理server.accept()里面
data_queue[r].put(data.upper()) # 然后就先不管了。等到select再监视的时候,会返回到writeable列表里。
# 所以后面还要写一个writeable的for循环
# 虽然是在上面的for循环里添加的,但是要等到在执行一次select后才会在writeable里有返回值
for w in writeable:
data = data_queue[w].get() # 从队列里取出数据。这里get了之后,这条消息就从队列里移除了
w.send(data) # 发数据,注意data的数据类型
outputs.remove(w) # 从outputs里移除这个活动的连接,否则下次过来还有尝试在发数据,但是消息队列里是空的
这里把之前客户端注释掉的内容去掉测试一下收数据。并且已经可以接入多个客户端了,开2个试一下就好了。
处理客户端断开的问题
剩下就是客户端断开的问题了。断开有两种情况:
一种是正常断开,客户端close(),会发送一个空给服务的,那么要在 data = r.recv(1024)
之后判断一下是不是空,就和之前写的socket服务器一样。
还有一种是强行关闭客户端,这时inputs仍然会收到活跃连接,但是recv的时候会抛出异常“ConnectionResetError”,这里大概要把recv放到try里,如果捕获到异常,就断开客户端。
另外还有一个exceptional异常列表有返回的情况,这里也粗暴的断开客户端处理了好了。
客户端断开就是要清除掉字典和列表中的这个连接的信息。
import select
import socket
import queue
server = socket.socket()
server.bind(('localhost', 9000))
server.listen()
print("监听已经开启")
server.setblocking(False) # 设置为非阻塞
inputs = [server, ]
outputs = []
data_queue = {} # 存放返回给客户端消息的队列,每个客户端连接一个队列,就是一个item
while True: # select返回活动链接==>for循环处理所有的活动链接,循环往复
# 返回3个数据,监视到活动的3个列表(读列表,写列表,异常列表)
readable, writeable, exceptional = select.select(inputs, outputs, inputs)
# 这里就是阻塞的,直到select监视到列表中有活动的链接,才会继续
print('select返回:\n', readable, writeable, exceptional)
for r in readable: # 可能一次返回多个连接啊,所以得写个循环
# 现在inputs里有server 和 conn了,
# 如果readable返回的是server的活动,表示来了一个新链接
# 如果readable返回的是conn的活动,表示收到了conn发来的数据
if r is server:
conn, addr = r.accept() # r就是server
print('接收到新的客户端连接:\n', conn, addr)
inputs.append(conn) # 将新连接加入到select监视列表中
data_queue[conn] = queue.Queue() # 创建新连接的消息队列
else:
# 这里有3中情况,有数据,有空数据(正常断开),无数据(一旦recv就报错)
try:
data = r.recv(1024)
except Exception as error:
print("recv时捕获到异常:%s" % error)
# 清除连接的4个操作,这段代码重复用了3次,应该专门写个函数引用
# 1 从读列表中清除,这里其实不用判断,但是后面的for循环里可能会尝试重复remove
# 2 如果还有没发出去的消息,把连接从写列表中清除
# 3 关闭连接
# 4 如果还有没发出去的消息,把消息队列的对象从字典里清除
if r in inputs:
inputs.remove(r)
if r in outputs:
outputs.remove(r)
r.close()
if r in data_queue:
del data_queue[r]
else:
# 这里处理能recv到数据,收到数据就加入outputs列表。为空就清除连接
if data:
print(data.decode('utf-8'))
outputs.append(r)
data_queue[r].put(data.upper())
else:
print("客户端已断开:\n", r)
inputs.remove(r)
if r in outputs:
outputs.remove(r)
if r in data_queue:
del data_queue[r]
# 虽然是上面的for循环里添加的,但是要等到在执行一次select后才会在writeable里有返回值
for w in writeable:
data = data_queue[w].get() # 从队列里取出数据。这里get了之后,这条消息就从队列里移除了
w.send(data) # 发数据,注意data的数据类型
outputs.remove(w) # 从outputs里移除这个活动的连接,否则下次过来还有尝试在发数据,但是消息队列里是空的
# 还有一个exceptional没处理,还是和上面一样,再写一个for循环
# 异常处理这里还是简单粗暴把异常列表中的连接清除就好了
for e in exceptional:
print("异常列表有返回:", e)
if e in inputs:
inputs.remove(e)
if e in outputs:
outputs.remove(e)
e.close()
if e in data_queue:
del data_queue[e]
现在就可以处理高并发了,写一个多线程的客户端,每个线程循环发数据测试一下。
测试客户端:
import socket
import threading
HOST = 'localhost'
PORT = 9000
def client(i):
client = socket.socket()
client.connect((HOST, PORT))
for j in range(100):
msg = "hello %s %s" % (i, j)
client.send(msg.encode('utf-8'))
data = client.recv(1024)
print('Received:', data.decode('utf-8'))
client.close()
if __name__ == '__main__':
for i in range(100):
t = threading.Thread(target=client, args=(i,))
t.start()
到这里感觉好了,但是还有3地方有问题,下面一个一个说明。上面的代码经不起强行断开客户端的考验。
send 和 recv 异常的问题
非阻塞模式下,如果调用recv()没有发现任何数据,或send()调用无法立即发送数据,那么将引起异常。我这里看到的是 "ConnectionResetError" 。
产生的原因是强行断开客户端,导致这个连接已经失效,但是连接还在select返回的列表里。这时之后的for循环里还会尝试去send或recv这个连接就会抛出异常。
解决办法 :send 和 recv 的时候都得用try,然后捕获到异常后,就把这个连接清理掉
改进writeable循环
data = data_queue[w].get()
这里有时候会报错 "KeyError" ,就是字典里已经没有这个key了。那就是在另外2个for循环里已经将这个key清除了。这里清除的时候没清writeable列表,所以在清除连接的时候加一句:
if r in writeable:
writeable.remove(r)
或者是用字典的get方法读取,这样在读取不存在的key的时候,会返回None:
data = data_queue.get(w)
if data:
data = data.get()
else:
if w in outputs:
outputs.remove(w)
continue
remove队列的问题
上面有3处地方会清除连接,这里可以另外写一个函数,需要清除的时候调用函数就好了。另外可能会再两个for循环里同时会要清除同一个连接,这样在第二次清除的时候如果不做if判断,就会报错无法删除列表里不存在的元素。这里保险起见还是在remove之前都加上if判断。应该只有第一个for循环里的inputs是一定有的不用判断,别的地方都可能会报错。
writeable的另外一个写法
说好了3个问题,这里还有一个暂时没事出问题,就是可能发数据的时候一次发不完。现在的写法都是默认一次send就是发完的,send之后直接从outputs里remove掉。
也可以换一种方法,send之后,不从移出outputs列表。那么下次while循环还会进来,此时get队列的时候要用get_nowait无阻塞模式取队列,如果空会抛出队列空的异常,那么这个一定是发完了。此时再把链接移出outputs列表。如果需要可以把上面字典 "KeyError" 一起处理了,继续用 data = data_queue[w].get()
取列表,放到try里,捕获2种异常分别处理掉。
后面的最终版本没这么用,我怕再踩到坑,先把想法记着。
小结 - 最终版本
下面给出一个所有遇到的问题都解决了的最终版本:
import select
import socket
import queue
server = socket.socket()
server.bind(('localhost', 9000))
server.listen()
print("监听已经开启")
server.setblocking(False) # 设置为非阻塞
inputs = [server, ]
outputs = []
data_queue = {} # 存放返回给客户端消息的队列,每个客户端连接一个队列,就是一个item
while True: # select返回活动链接==>for循环处理所有的活动链接,循环往复
# 返回3个数据,监视到活动的3个列表(读列表,写列表,异常列表)
readable, writeable, exceptional = select.select(inputs, outputs, inputs)
# 这里就是阻塞的,直到select监视到列表中有活动的链接,才会继续
print('select返回:\n', readable, writeable, exceptional)
for r in readable: # 可能一次返回多个连接啊,所以得写个循环
# 现在inputs里有server 和 conn了,
# 如果readable返回的是server的活动,表示来了一个新链接
# 如果readable返回的是conn的活动,表示收到了conn发来的数据
if r is server:
conn, addr = r.accept() # r就是server
print('接收到新的客户端连接:\n', conn, addr)
conn.setblocking(False)
inputs.append(conn) # 将新连接加入到select监视列表中
data_queue[conn] = queue.Queue() # 创建新连接的消息队列
else:
# 这里有3中情况,有数据,有空数据(正常断开),无数据(一旦recv就报错)
try:
data = r.recv(1024)
except Exception as error:
print("recv时捕获到异常:%s" % error)
# 清除连接的4个操作,这段代码重复用了3次,应该专门写个函数引用
# 1 从读列表中清除,这里其实不用判断,但是后面的for循环里可能会尝试重复remove
# 2 如果还有没发出去的消息,把连接从写列表中清除
# 3 关闭连接
# 4 如果还有没发出去的消息,把消息队列的对象从字典里清除
if r in inputs:
inputs.remove(r)
if r in outputs:
outputs.remove(r)
r.close()
if r in data_queue:
del data_queue[r]
else:
# 这里处理能recv到数据,收到数据就加入outputs列表。为空就清除连接
if data:
print(data.decode('utf-8'))
if r not in outputs: outputs.append(r)
data_queue[r].put(data.upper())
else:
print("客户端已断开:\n", r
if r in inputs:
inputs.remove(r)
if r in outputs:
outputs.remove(r)
r.close()
if r in data_queue:
del data_queue[r]
# 虽然是上面的for循环里添加的,但是要等到在执行一次select后才会在writeable里有返回值
for w in writeable:
data = data_queue.get(w) # 先从字典里取出这个队列
if data: # 队列存在,取数据
data = data.get() # 从队列里取出数据。这里get了之后,这条消息就从队列里移除了
else: # 队列不存在,这个连接已经被清除了,remove掉,下一个循环
if w in outputs:
outputs.remove(w)
continue
try:
w.send(data) # 发数据,注意data的数据类型
except Exception as error:
print("send时捕获到异常:%s" % error)
if r in inputs:
inputs.remove(r)
if r in outputs:
outputs.remove(r)
r.close()
if r in data_queue:
del data_queue[r]
else:
if w in outputs:
outputs.remove(w) # 有可能一次send不完,这里也可以不remove,用另外一个方法
# 开头用get_nowait无阻塞模式取队列,捕获到队列为空的异常,再remove掉这个连接
# 还有一个exceptional没处理,还是和上面一样,再写一个for循环
# 异常处理这里还是简单粗暴把异常列表中的连接清除就好了
for e in exceptional:
print("异常列表有返回:", e)
if e in inputs:
inputs.remove(e)
if e in outputs:
outputs.remove(e)
e.close()
if e in data_queue:
del data_queue[e]
学了那么多都没用,应该也用不到,而且可能还会有别的问题。最可怕的是别人都不这么用,有问题都找不到人解决。主要是通过select的使用来了解IO多路复用。除了select,还有poll和epoll。
epoll 更高效,但是代码也更复杂。不过这些我们都用不到,都太底层了。平时用用已经封装好的模块就好了。这里通过学习大概了解一下底层是怎么实现的。剩下的会用模块就好了,现在至少知道模块中是怎么运作的了。
最后就是学一下下面的已经封装的selectors模块,底层都清楚了,学习使用下面的模块已经没有难度了。
selectors 模块
平时直接用已经封装好的模块,简单坑又少。selector模块,默认会用epoll,如果系统不支持,就用select,完美。
理解了前面select的机制,在使用这个模块就简单了。步骤都一样。步骤都一样,但是都封装好了。
import selectors
import socket
def accept(sock, mask):
"""建立新连接并注册"""
conn, addr = sock.accept()
print('接收到新的客户端连接:\n', conn, addr)
conn.setblocking(False) # sock里已经设置为False,这里貌似没意义,反正没差
# 上面已经建立好连接了,把新连接注册到sel里,这是第二次注册了
# 第一次注册是注册server接受客户端连接请求的连接
# 这里是连接建立后收发数据的连接,这个连接如果发现是活动的,调用的就是read方法了
sel.register(conn, selectors.EVENT_READ, read)
def read(conn, mask):
"""接收数据"""
data = conn.recv(1024)
if data:
print(data.decode('utf-8'))
conn.send(data.upper())
else:
print("客户端已断开:\n", conn)
sel.unregister(conn) # 注销这个连接
conn.close()
def server(port):
sock = socket.socket()
sock.bind(('localhost', port))
sock.listen()
print("监听已经开启")
sock.setblocking(False)
# 下面就是select方法,也可能是epoll
# 注册你的socket,就是让select监视,监视到有活动的连接,就调用accept函数
sel.register(sock, selectors.EVENT_READ, accept)
# 上面还没有开始监视,只是先把select准备好
while True:
events = sel.select() # 这里就还是监视了
# 这里会阻塞,一旦有活动的连接,就会返回给events列表
for key, mask in events:
callback = key.data # key.data就是sel.register里的accpet这个函数
# 现在callback就是accpet这个函数了,下面加上括号填上参数就执行了
callback(key.fileobj, mask) # key.fileobj就是sel.register里的sock
if __name__ == '__main__':
sel = selectors.DefaultSelector() # 老套路,用之前先实例化一个对象
server(10001)
还是有那个老问题,客户端强制断开,服务端会报错 "ConnectionResetError" 。
作业
SELECT版FTP :
- SELECT或SELECTORS模块实现并发简单版FTP
- 允许多用户并发上传下载文件