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)