python_21_线程+进程+协程

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分钟可以完成，对于处理者来说我怎么处理，

　　　　排队的人不需要关心，处理者只需要把资料拷贝好了交给排队者就行了

1. 解耦
2. 提高效率

如何生成使用一个队列？

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上运行

  如何实现？

1. 导入pool，在multiprocessing中
2. 实例pool，process = 进程池进程数量
3. 实例进程，”.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模式？

1. 等待内核数据准备
2. 将数据从内核拷贝到进程中

linux操作系统产生哪些网络模式？

1. 堵塞IO                 – 等数据，拷贝数据
2. 非堵塞IO              -- 没数据返回erro，一旦有数据并且收到请求，拷贝数据，需要一直检测
3. IO多路复用           -- select,poll,epoll
4. 信号驱动IO
5. 异步IO                  -- python模块 asyncio

什么是异步IO？

不会导致请求IO用户的堵塞。用户请求，滚，把数据送到用户家门口

　　任何堵塞是服务器堵塞，任何模式都是改变用户等待请求的方式

什么是IO多路复用？

　　-- select,poll,epoll区别？

select：一种循环检测请求数据，数据来了，内核告诉用户数据来了，保密，需要用户循环接收

poll：

　　epoll： 一种循环检测请求数据，数据来了，告诉用户数据来了，哪个活跃，用户拿着这两个数据去取数据

　　不取数据，数据本身还在内核空间中，内核每次都通知用户去取       -- 水平触发

　　不取数据，数据本身还在内核空间中，内核不再通知用户去取           -- 边缘触发

如何使用select建立一种socket模型,实现并发？

1. 导入select，socket模块
2. IO设置为非堵塞（server.setblocking(Flase)）
3. 设置select检查对象，并且让selet循环
4. 每进来一个新的连接，加入到select检查列表中，如果连接发数据，活动起来，设置一个队列进行put客户端发来的数据
5. 通过下次循环开始，再把处理数据发送给客户端，虽然慢了一步，但是实现了封装
6. 通过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)