python_线程_进程_协程
什么是线程？
-- os能够进行运算调度的最小单位，被包含在进程之中，是一串指令的集合
-- 每个线程都是独立的，可以访问同一进程下所有的资源
什么是进程？
-- 每个进程独立，对应的内存也独立，不可互相访问，为了安全
-- 包含各种对资源的调用，各种资源的集合，以一个整体暴露给os管理
-- 进程要操作cpu，必须先创建一个线程，
-- 进程只是向操作系统要了资源，通过线程才能使用资源
-- 一个进程至少有一个主线程，其主线程可以创建子线程，子线程又可以创建子线程
进程快还是线程快？
这个问题本身有问题！
进程与线程区别？
-- 线程共享内存空间，进程内存是独立的，
-- 虽然是克隆相同的数据，但两个子进程数据都是两个独立的数据
-- 同一个进程的线程之间可以直接交流，两个进程想通信，必须通过一个中间代理来实现
-- 创建新线程很简单，创建新进程需要对父进程进行一次克隆
-- 一个线程可以控制和操作同一进程里的其他线程，但是进程只能操作子进程
-- 修改主线程，可能会影响其他线程运行行为，修改父进程而并不是删除，子进程不会受到影响
什么是并发？
-- 假如阅读一本书，我只需要记住读到了第几页，第几行，第几个字符，
也就是说只要记住3个数字，可以在休息完了之后，接着读，室友在我休息的时候，
也可以按此方法阅读这本书，从而实现书的共享和利用率，把这本书同样看作cpu，
依据上下文，就可以实现快速的切换线程，进程
-- 单核cpu依据上下文，实现快速的切换，给了一个幻觉，可以同时执行多个任务，实际上，任何时候只能执行一个线程
-- 对于多核心cpu实实在在同时可以执行多个任务
什么是python GIL？
-- 多核cpu可以同时执行多个线程
-- 全局解释器锁
-- 在python中无论启动多少个线程，无论cpu有多少核心，python在执行的时候，
会淡定的在同一时刻只允许一个线程运行，。
-- python线程调用os原生线程，c语言原生线程接口，必须把上下文传给os，对于调用接口，
解释器无法对cpu处理顺序处理，解释器无法控制线程执行顺序，只能调用等结果，
对于结果有可能对，有可能错，多个线程可以同时多核执行，但同时只有一个线程对结果进行修改，
Cpython才有这个问题
如何实现一个最简单的多线程？
import threading #导入线程模块
import time
def run(n): # run可以随便改名
print("talk", n)
time.sleep(2) t_1 = threading.Thread(target=run, args =('t1',)) # 实例一个线程
# target =目标函数 ，args =参数(元组形式，一个参数也要加逗号)
t_2 = threading.Thread(target=run,args=('t2',)) t_1.start() # 启动线程
t_2.start()
还有个方式，通过类来写
import threading
import time
class MyThread(threading.Thread): # 继承threading.Thread
def __init__(self,name): # 重构父类析构函数
super(MyThread,self).__init__() # 继承父类析构函数
self.name = name
def run(self): # 必须写run
print('talk',self.name)
time.sleep(2) if __name__ == '__main__':
t_1 = MyThread('t1') # 实例一个线程
t_2 = MyThread('t2') t_1.start()
t_2.start()
-- 对于主线程和子线程来说，程序本身就是个主线程，主线程执行时候并不等待子线程，对于整个程序主线程结束时候，会等待子线程全部结束
如何实现简单计算线程运行时间？
import threading
import time class MyThread(threading.Thread):
def __init__(self,name):
super(MyThread,self).__init__()
self.name = name
def run(self):
print('talk',self.name)
time.sleep(2)
print('%s is done'%self.name) start_time = time.time()
if __name__ == '__main__':
list_t = [] # 通过列表关联有多少个线程，循环此列表进行线程等待
for i in range(50):
t = MyThread(i) # 实例一个线程
# t.setDaemon(True) # 此为守护线程声明，不重要，必须在start前面加
t.start()
list_t.append(t) # 每实例一个线程都加入列表，通过列表长度判断添加了几个进程
for i in list_t:
t.join() # 循环列表，给每个线程加上join()等待，当子线程成为守护线程时候，不需要join
end_time = time.time() print('running time is : %s'%(end_time - start_time)) print('The mian process.....')
通过 ”线程名.join()” 来进行等待子线程结束，主线程才继续执行
对于多线程同时共享一份数据，更改同一份数据，有哪些坑？
-- GIL 锁 + - 数据进行修改多了，修改不准，大坑，GIl 锁只能保证同一时间只有一个线程在执行，
可以使用thread lock保证同一时间只有一个进程进行数据修改，在修改的时候，保证线程串行，
在2.x版本有问题，在3.x此问题解决了，但还是要加上锁，官方没有声明
在2.x上如何解决？
lock = threading.Lock() #实例化锁
def run(self):
lock.acquire #加锁，其他线程进入等待状态
global num
num += 1
lock.release() #释放锁
-- 但是此锁在有嵌套锁的时候，就会出现锁住无法释放锁的时候，就得使用递归锁
lock = threading.RLock() --R表示递归锁
-- 互斥锁，同时只允许一个线程修改数据。
什么是守护线程？
-- 主线程执行完，退出，不管守护线程是否执行完毕，程序全部退出，主人+奴隶
-- 启动线程之前，加上 “线程对象.setDaemon(True)”
如何查看主线程和活跃的线程计数？
threading.current_thread() # 查看主线程
threading,active_count() #查看活跃线程格式
什么是信号量？
-- 信号量和锁一样，拥有多把锁，分配锁，让有锁的线程修改数据，
也说明同时让有锁的线程并行，没有锁的等待，完成的线程释放锁，
等待线程依次获得锁，但是锁数量是有限制的
先实例一个semphore对象 “semphore = threading.BoundedSemaphoer(5)”
# 同时运行5个获得锁的线程
def run(self):
semphore.acquire #加锁，其他线程进入等待状态
global num
num += 1
semphore.release() #释放锁
什么是事件？
-- Events 进行不同线程之间同步数据
（红绿灯，每隔多少秒变灯，车子不停检查灯的状态，红灯停，绿灯行，
本质上声明全局变量，红绿灯满足条件更改全局变量，车子不停检查全局变量）
event = threading,Event()
event.set() # 设置标志位
event.clear() # 清空标准位
event.is_set() # 判断标志位是否设置
event.wait() # 标志位被清空一直堵塞状态，直到标志位再次设定不堵塞状态
如何实现一个红绿灯程序？
import threading
import time event = threading.Event() # 声明事件 def light(): # 定义红灯
event.set() # 设置事件
conut = 0 # 计时
while True:
if conut > 5 and conut < 10: # 在5到10秒内，红灯，清空事件
event.clear()
print('light red........')
elif conut > 10 : # 绿灯，设置事件
event.set()
print('light green.......')
conut = 0
else:
print('light green.......')
time.sleep(1)
conut += 1 def car(name): # 定义车
while True:
if event.is_set(): # 检查事件状态，如果是红灯就停止
print('[%s] is run......'%name)
time.sleep(1)
else:
print('[%s] is wait......'%name)
event.wait() # 被清空处于堵塞状态
print('[%s] is run......' % name) if __name__ == '__main__':
light_1 = threading.Thread(target=light) # 实例红灯线程
light_1.start() # 启动
car_1 = threading.Thread(target=car,args=('哈士奇',)) # 实例车进程
car_1.start() # 启动
什么是队列？
-- 一种数据类型容器，先进先出
列表和队列的区别？
-- 列表取出一个数据，列表中那个数据还在
-- 但对于队列数据，取走一个少一个
为什么需要队列？
-- 提高排队者和处理者的效率
--比如50个人拷贝一份资料，一份的时间5分钟，把U盘留下，按顺序来，排队者可以不用排起队，
干等着，可以在这段时间去干其他事，计算号时间然后去拿就行了，对于处理者来说，
1个人处理要250分钟，加1个人帮忙，只要125分钟可以完成，对于处理者来说我怎么处理，
排队的人不需要关心，处理者只需要把资料拷贝好了交给排队者就行了
- 解耦
- 提高效率
如何生成使用一个队列？
queue 模块，有三种队列，先进先出+后进先出+设置优先级队列
q = queue.Queue(block=True，maxsize =数字) --实例一个q对象,先进先出
-- block 默认等于True，取数据没有的时候一直处于堵塞状态，等待放入数据
-- maxsize 默认不写，任意put数据，写的，多了处于堵塞状态，需等待数据取出再放入
q = queue.LifoQuenue(maxsize=0) -- 后进先出
q = queue,PriorityQueue(maxsize=0) -- 设置优先级
-- q.put((优先级，数据)) -- 数字越小优先级高
q.put(block=True，timeout=None) -- 放入一个元素
q.qsize() -- 查看长度
q.get(block=True，timeout=None)
-- 取一个数据，当没数据时候，一直等待放入数据然后取状态，堵塞状态
q.get_nowait() -- 取一个数据，当没数据时候，抛出异常
q.get(timeout = 1) -- 取数据1秒钟，1秒钟之后没有数据抛出异常
什么是生产与消费模型？
-- 用于解决大多数并发问题，平衡生成能力和消费能力来提高整体处理数据能力
-- 生产者和消费者之间不彼此通信，对于生产者只需要把生产的商品放入队列，
队列满了，停止生产，等待消费者从队列中消费商品。对于消费者，
只需要到队列中拿商品，队列商品没了，进入等待状态，等队列中出现新的商品。
-- 供求关系
如何实现？
import threading
import time
import queue q = queue.Queue(maxsize=10) def p(name):
count = 1
while True:
print('%s生产第%s包子'%(name,count))
q.put('包子%s'%count)
count += 1
time.sleep(1) def s(name):
while True:
q.get()
print('%s作死的吃，如狼似虎'%name)
time.sleep(1) if __name__ == '__main__':
p1 = threading.Thread(target=p, args=('一枝花',))
s1 = threading.Thread(target=s, args=('北门吹雪',))
s2 = threading.Thread(target=s, args=('西门吹风',)) p1.start()
s1.start()
s2.start()
-- I/O操作不占用cpu，读取输入输出
-- 计算占用cpu，数学运算不适合多线程
-- python多线程，不适合cpu密集操作型的认为，适合I/O密集型的任务,(socketserver)
-- python中启多个进程，每个进程都有一个主线程，运用多进程来实现多核心cpu同时运行的问题
-- 在linux中每个子进程都是由父进程启动的，必有一个根进程
如何启动多进程？
imoprt multprocessing #导入多进程模块
p = multiprocessing.Process(target = 方法，args = 元组)
p.start()
# 多进程的语法规则和多线程执行方法类似，进程中可以嵌套启动线程
os.getppid() #获得当前父进程id
os.getpid() #获得当前程序子进程id
如何让两个进程之间进行通信？
queue # 线程 队列 ，线程之间共享数据
Queue # 进程 队列 ，进程之间共享数据
进程之间数据和内存地址是独立的，无法互相访问各自的内存地址
-- 如果把线程q当做一个一个参数传给子进程，相当于序列化传给子进程
-- 对于进程Q，把Q对象当做参数传入子进程，相当于克隆了一份一样的，本质上是pikle
一份传给个子进程，本质上虚拟出一个中间Q，子进程load一下，父进程dump一下
实现代码：
from multiprocessing import Process,Queue # 导入 def child_1(Q):
Q.put('hello') if __name__ == '__main__':
q = Queue()
p = Process(target=child_1, args=(q,))
p.start()
p.join()
print(q.get())
实现了一个进程放数据，另外一个进程拿到数据
还有个pipes实现进程之间通信？
-- 相当于建立起电话连接，类似socket，发一条收一条，多收了就会进入等待状态
from multiprocessing import Process,Pipe def child_1(Q):
print('来自一枝花的祝福:',Q.recv())
Q.send('兄弟，好久没见面了') if __name__ == '__main__':
brother_1, brother_2 = Pipe()
p = Process(target=child_1, args=(brother_2,))
p.start()
brother_1.send('北门吹雪可好？')
print("来自北门吹雪的回话:",brother_1.recv())
p.join()
上面只是完成数据的传递，而不是共享，如何解决？
进程之间可以通过Manager进行共享数据？
-- 本质上和Queue一样
from multiprocessing import Process,Manager
import os def show(d,l):
d[os.getpid()] = os.getpid() #每个进程都修改共享字典
l.append(os.getpid()) #每个进程都修改共享列表
if __name__ == '__main__':
with Manager() as manager: # 等价于manager = Manager()
d = manager.dict() # 生成一个共享字典
l = manager.list() # 生成一个共享列表
p_list = [] # 确定每个进程都完成的列表
for i in range(10):
p = Process(target=show, args=(d,l)) #把共享列表和字典当做参数传入进程
p.start()
p_list.append(p)
for p in p_list: #确定每个进程都完成
p.join()
print(d,l)
# 对于此处，修改数据不需要加锁，Manager自动加上锁了
如何逻辑整理？
-- Queue、Pipe、Manager、Process模块都是multiprocessing模块中自带
-- Queue、Manager实现通信的本质上是一样的，
- 但是Queue只能实现简单的put和get，
Manager不仅可以实现共享字典和列表，还可以进行任何对共享字典和列表的操作
-- Pipe的使用，有点类似socket，开始实例两个通信对象，然后把其中一个对象当做参数，传入另外一个进程，同时send，recv实现进程之间通信
-- Queue、Pipe、Manager实现通信的逻辑，都是先生成通信对象的中间桥梁，通过线程实例化的时候，把通信对象当做参数传入进去，从而实现通信
-- 现实生活中，要想打电话的前提，必须要有手机，手机就是其中沟通的桥梁
什么是进程锁？
-- 锁住对屏幕资源的抢占，和线程锁一毛一样，先从multiprocessing中导入Lock，
然后生成锁的实例，然后把锁当做参数传入进程实例，通过 .acquire() 锁上屏幕输出，.release()释放锁
什么是进程池？
-- 同一时间规定多少个进程在cpu上运行
如何实现？
- 导入pool，在multiprocessing中
- 实例pool，process = 进程池进程数量
- 实例进程，”.apply”表示同步（串行），”.apply_async”表示异步（并行）
func = 进程函数，args =(进程参数，)，callback = 回调函数（异步才有）
回调函数是每个子进程执行完毕，再调用此函数，是主线程进程调用的，提高运行效
先pool.close()，再pool.join()，大坑，逻辑上是先join再close，但是此处不符合逻辑
逻辑代码
from multiprocessing import Pool
import os
import time def show(q): # 进程函数
time.sleep(2)
print(os.getpid()) def callback_1(a): # 回调函数，主进程调用
print('回调函数',os.getpid()) if __name__ == '__main__':
with Pool(5) as pool: # 线程池只有5个进程，相当于pool = Pool(5)
for i in range(10): #启动10个进程
pool.apply_async(func=show,args=(i,),callback=callback_1)
pool.close() # 坑，先close再join，逻辑坑
pool.join()
什么是协程？
-- 微线程，一种用户态的轻量级线程
-- 单线程实现并发，本质上在不同函数中来回切换，串行，通过yield
优点：
- 无需线程上下文切换
- 无需原子操作锁定及同步的开销
- 方便控制流，简化编程模型
- 高并发+高扩展+低成本，一个cpu可以运行上万个协程
缺点：
- 无法利用多核心cpu，需要和进程进行配合使用
协程的逻辑？
-- 通过yield，让函数变成生成器，先通过实例一个迭代对象，
然后通过迭代对象.__next__()方法进行函数一次调用，遇到yield函数跳出当前函数执行，
去执行其他逻辑函数，其他函数中通过迭代对象.send(参数)方法，参数被迭代器函数yield接收到，
唤醒迭代对象函数，执行yield函数下的函数体，再次遇到yield，再次跳出来，
回到 “对象.send(参数)”后面的逻辑函数，一遇到对象.send(参数)，
又回到对象函数中yield函数后面的逻辑函数执行，如此反复，在程序中进行跳转，给了一个多并发的幻觉
-- 实现模型是生产者消费模型？
import time def producer(name): # 定义一个生产者
c_1.__next__() # 生成器调用
c_2.__next__()
for i in range(2,100,2):
print('%s生产了[%s]包子'%(name,i))
c_1.send(i)
# 跳出此函数，唤醒c_1迭代器中yield后面的逻辑函数并且执行，一遇到yield或者
# c_1迭代对象函数已经执行完了，又跳回到此处，继续执行
c_2.send(i)
def consumer(name):
print('开始要吃包子了')
while True:
baozi = yield
print('%s正在吃包子%s'%(name,baozi))
time.sleep(1) if __name__ == '__main__':
c_1 = consumer('一枝花')
c_2 = consumer('北门吹雪')
p = producer('酒酒')
-- 上面有个问题，生产者无任何堵塞，幻觉上实现了并发，但是一旦生成者有堵塞，就会有卡顿，如何解决？
协程如何实现的？
-- 一遇到io请求，协程把io请求和回调函数交个os，os处理完了调用回调函数，通知我，然后又跳回来执行剩下的逻辑处理，如此反复
协程切换原则？
-- 遇到I/O操作就切换，那什么时候切回去？I/O操作完成切换回去
-- 通过 greenlet手动的切换协程
代码实现：
from greenlet import greenlet # 导入协程模块 def f1(): # 定义一个协程函数1
print(1) # 协程1切换执行的函数
g_2.switch() # 切换到协程函数2，也是协程函数1的回来执行得起点
print(2) # 协程1切换回来执行函数
g_2.switch() # 切换到协程2函数 def f2(): # 定义协程2函数
print(3) # 协程2执行的函数
g_1.switch() # 切换到协程函数1，也是协程函数2的回来执行得起点
print(4) # 协程2执行的函数 g_1 = greenlet(f1) # 启动协程1
g_2 = greenlet(f2) # 启动协程2，启动协程并不代表，执行协程函数 g_1.switch() # 执行协程1
- 以上函数虽然实现了协程，但是手动执行，没有自动化
如何实现自动挡协程？
import gevent # 引入协程模块 def f1(): # 定义协程函数
print('hello 1') # cpu处理
gevent.sleep(3) # 模拟i/o操作，跳出
print('hellw 1 again') def f2():
print('hello 2')
gevent.sleep(2)
print('hello 2 again') def f3():
print('hello 3')
gevent.sleep(4)
print('hello 3 again') gevent.joinall([
gevent.spawn(f1), # 启动协程
gevent.spawn(f2),
gevent.spawn(f3), ])
-- 上面代码牛逼之处在于，代码的中运行时间与最大运算时间有关，
上面代码最长运行时间4秒，一遇到io操作就切换，依次从上往下跳，
自动检查I/O操作是否完成，实际上I/O操作和程序执行进行了异步，分开了
如何使用协程进行大并发爬网页？
-- urlib 和socket，gevent无法直接知道其中I/O操作
如何实现？
import requests
import gevent
from gevent import monkey monkey.patch_all() # 把当前程序的所有的io操作给单独做上标记，打上补丁 def pa(url):
try:
r = requests.get(url, timeout=30)
r.raise_for_status()
r.encoding = r.apparent_encoding
data = r.text
print(url, data)
except:
print(url, '爬取错误') gevent.joinall([
gevent.spawn(pa, 'http://www.ithome.com'),
gevent.spawn(pa, 'http://www.baidu.com'),
gevent.spawn(pa, 'http://lol.qq.com')
])
如何实现高效socketserver？高并发？
服务端:
import socket # 导入socket
import gevent # 导入协程模块
from gevent import monkey # 导入协程标记模块 monkey.patch_all() # 启动协程标记 def server(port): # 定义socket服务
s = socket.socket() # 实例socket服务
s.bind(('localhost',port)) # 绑定端口
s.listen(5) # 启动监听
while True: # 提供服务
conn, addr = s.accept() # 监听对象和对象地址
gevent.spawn(handle, conn) # 启动处理请求协程 def handle(Q): # 定义处理函数
while True: # 循环接收客户端请求
try:
data = Q.recv(1024) # 接收数据
print(data.decode('utf-8')) # 打印接收数据
Q.send(data.upper()) # 发送处理数据
except Exception as e: # 异常打印
print(e) # 打印异常
break # 异常跳出程序 if __name__ == '__main__':
server(6969) # 输入端口，启动服务
什么是用户空间和内核空间？
os采用虚拟存储器，对32os，寻址空间为2的32次方
os的核心是内核，独立于普通的应用程序，可以访问保护的内存空间，也有访问底层硬件设备的所有权限
为了保护内核的安全，用户进程不能直接操作内核，os把虚拟空间划分为两个部分，一个是内核空间，另外一个是用户空间
什么是进程切换？
内核有能力挂起正在运行的进程，并恢复以前挂起的某个进程，
进程的堵塞状态是进程本身主动请求的，通过进程的上下文，快速的在cpu中运行与堵塞
什么是进程堵塞？
进程请求资源失败、等待某种操作完成、无工作可做等状态，则有os自动执行堵塞原语（block），
让*运行的进程，进入堵塞状态，获得cpu资源的进程才有堵塞状态，
堵塞状态不占用cpu资源，堵塞状态是进程的一种主动请求
什么是文件描叙符？
-- 形式上是一个非负整数，实际上它是一个索引值，指向内核为每一个进程所维护的改进程打开文件的记录表
-- 当程序打开一个现有的文件或者创建一个新文件的时候，内核向进程返回一个文件描叙符
什么是缓存IO？
数据先被拷贝到内核缓存区中，然后才会从os内核中拷贝到应用程序地址空间
-- 数据 ——》内核空间——》用户空间
-- 数据的反复拷贝，cpu和内存资源开销非常大
什么是IO模式？
- 等待内核数据准备
- 将数据从内核拷贝到进程中
linux操作系统产生哪些网络模式？
- 堵塞IO – 等数据，拷贝数据
- 非堵塞IO -- 没数据返回erro，一旦有数据并且收到请求，拷贝数据，需要一直检测
- IO多路复用 -- select,poll,epoll
- 信号驱动IO
- 异步IO -- python模块 asyncio
什么是异步IO？
不会导致请求IO用户的堵塞。用户请求，滚，把数据送到用户家门口
任何堵塞是服务器堵塞，任何模式都是改变用户等待请求的方式
什么是IO多路复用？
-- select,poll,epoll区别？
select：一种循环检测请求数据，数据来了，内核告诉用户数据来了，保密，需要用户循环接收
poll：
epoll： 一种循环检测请求数据，数据来了，告诉用户数据来了，哪个活跃，用户拿着这两个数据去取数据
不取数据，数据本身还在内核空间中，内核每次都通知用户去取 -- 水平触发
不取数据，数据本身还在内核空间中，内核不再通知用户去取 -- 边缘触发
如何使用select建立一种socket模型,实现并发？
- 导入select，socket模块
- IO设置为非堵塞（server.setblocking(Flase)）
- 设置select检查对象，并且让selet循环
- 每进来一个新的连接，加入到select检查列表中，如果连接发数据，活动起来，设置一个队列进行put客户端发来的数据
- 通过下次循环开始，再把处理数据发送给客户端，虽然慢了一步，但是实现了封装
- 通过select返回的erro列表，如果连接断开，删除检查列表中连接对象，删除队列中连接对象数据
#!/usr/bin/python3
import socket
import select
import queue server = socket.socket()
server.bind(('localhost',6969))
server.listen(5) # 声明协议，启动监听
server.setblocking(False) #设置为非堵塞 inputs = [server,] #生成检测列表
#inputs = [server,conn,conn2]
outputs = [] # 下次循环开始就返回上次循环加入的数据
client_data = {} # 定义一个接收各个连接客户端发来数据的字典 while True: # 让select一直检测
readable, writeable, exceptional = select.select(inputs,outputs,inputs)
print(exceptional) # readable, writeable, exceptional，三个对象是固定参数，不可更改
for r in readable: # readable中返回的是活动的连接列表，不活动不返回，r是活着的连接
if r is server: # 判断是否有新的连接
conn, addr = server.accept() # 接收数据，非堵塞
inputs.append(conn) # 把新的连接加入到select中检测
client_data[conn] = queue.Queue() # 一个新的连接生成一个队列对象
else:
try:
data = r.recv(1024) # 接收数据
client_data[r].put(data) # 把数据放入字典中的队列中
outputs.append(r) # 向outputs 中加入连接对象,下次循环返回给writeable
except Exception as e:
print(r)
inputs.remove(r) # 远程客户端断开连接，移除检查对象 for w in writeable: # 循环把客户端的发来的请求处理发回给客户端
send_data = client_data[w].get() # 获取队列中请求
w.send(send_data.upper()) # 发送处理的数据
outputs.remove(w) # 发完了，移除output中连接对象
# 实际上更加慢了，装逼，包装
for e in exceptional: # 断开连接
if e in outputs: # 判断是否连接对象在outputs中
outputs.remove(e) # 删除outputs连接对象
inputs.remove(e) # 建立连接就会在inputs中
del client_data[e] # 删除连接对象的字典中队列数据
什么是selectors模块？
-- 封装了select和epoll，默认优先级epoll先，不支持epoll才切换成select
import selectors
import socket sel = selectors.DefaultSelector() def accept(sock, mask):
conn, addr = sock.accept() # Should be ready
print('accepted', conn, 'from', addr)
conn.setblocking(False)
sel.register(conn, selectors.EVENT_READ, read) def read(conn, mask):
data = conn.recv(1000) # Should be ready
if data:
print('echoing', repr(data), 'to', conn)
conn.send(data) # Hope it won't block
else:
print('closing', conn)
sel.unregister(conn)
conn.close() sock = socket.socket()
sock.bind(('localhost', 10000))
sock.listen(100)
sock.setblocking(False) sel.register(sock, selectors.EVENT_READ, accept) while True:
events = sel.select()
for key, mask in events:
callback = key.data
callback(key.fileobj, mask)