一：IO模型简洁

* blocking IO           阻塞IO
* nonblocking IO      非阻塞IO
* IO multiplexing      IO多路复用
* asynchronous IO    异步IO
	由于 signal driven IO（信号驱动IO）不常用，所以主要介绍其余4种

1.等待数据准备（Waiting for the data to be ready）
2.将数据从内核拷贝到进程中（Copying the data from the kernel to the process）

001

同步异步
阻塞非阻塞
常见的网络阻塞状态：
	accept
	recv
	recvfrom
	
	send虽然它也有IO行为 但是不在我们的考虑范围

二：阻塞IO

005

我们之前写的都是阻塞IO模型	协程除外

import socket

server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)

while True:
    conn, addr = server.accept()
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0:
                break
            print(data)
            conn.send(data.upper())

        except ConnectionResetError as e:
            print(e)
    conn.close()
    
# 在服务端开设多进程或者多线程，进程池线程池，其实还是没有解决IO问题
该等的地方还是得等 没有规避
只不过多个人等待的时候 彼此互不干扰

三：非阻塞IO

003

服务端：

import socket
import time


server = socket.socket()
server.bind(('127.0.0.1', 8081))
server.listen(5)
server.setblocking(False)
# 将所有的网络阻塞变为非阻塞
r_list = []
del_list = []
while True:
    try:
        conn, addr = server.accept()
        r_list.append(conn)
    except BlockingIOError:
        # time.sleep(0.1)
        # print('列表的长度:',len(r_list))
        # print('做其他事')
        for conn in r_list:
            try:
                data = conn.recv(1024)  # 没有消息 报错
                if len(data) == 0:  # 客户端断开链接
                    conn.close()  # 关闭conn
                    # 将无用的conn从r_list删除
                    del_list.append(conn)
                    continue
                conn.send(data.upper())
            except BlockingIOError:
                continue
            except ConnectionResetError:
                conn.close()
                del_list.append(conn)
        # 挥手无用的链接
        for conn in del_list:
            r_list.remove(conn)
        del_list.clear()

客户端：

import socket


client = socket.socket()
client.connect(('127.0.0.1',8081))


while True:
    client.send(b'hello world')
    data = client.recv(1024)
    print(data)

总结：

虽然非阻塞IO给你的感觉非常牛逼
但是该模型会 长时间占着CPU不用  让CPU不停的空转 占着茅坑不拉屎
我们实际应用中也不会考虑使用非阻塞IO模型

任何的技术点都有它存在的意义 
实际应用或者是思想借鉴

四：IO多路复用

002

当监管的对象只有一个的时候 其实IO多路复用连阻塞IO都比比不上！！！
但是IO多路复用可以一次性监管很多个对象

server = socket.socket()
conn,addr = server.accept()

监管机制是操作系统本身就有的 如果你想要用该监管机制(select)
需要你导入对应的select模块

服务端：

import socket
import select


server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen(5)
server.setblocking(False)
read_list = [server]


while True:
    r_list, w_list, x_list = select.select(read_list, [], [])
    """
    帮你监管
    一旦有人来了 立刻给你返回对应的监管对象
    """
    # print(res)  # ([<socket.socket fd=3, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8080)>], [], [])
    # print(server)
    # print(r_list)
    for i in r_list:  #
        """针对不同的对象做不同的处理"""
        if i is server:
            conn, addr = i.accept()
            # 也应该添加到监管的队列中
            read_list.append(conn)
        else:
            res = i.recv(1024)
            if len(res) == 0:
                i.close()
                # 将无效的监管对象 移除
                read_list.remove(i)
                continue
            print(res)
            i.send(b'heiheiheiheihei')

客户端：

import socket


client = socket.socket()
client.connect(('127.0.0.1',8080))


while True:

    client.send(b'hello world')
    data = client.recv(1024)
    print(data)

总结：

监管机制其实有很多
select机制  windows linux都有

poll机制    只在linux有   poll和select都可以监管多个对象 但是poll监管的数量更多

上述select和poll机制其实都不是很完美 当监管的对象特别多的时候
可能会出现 极其大的延时响应

epoll机制   只在linux有
   它给每一个监管对象都绑定一个回调机制
   一旦有响应 回调机制立刻发起提醒

针对不同的操作系统还需要考虑不同检测机制 书写代码太多繁琐
有一个人能够根据你跑的平台的不同自动帮你选择对应的监管机制
selectors模块

五：异步IO

004

异步IO模型是所有模型中效率最高的 也是使用最广泛的
相关的模块和框架
   模块:asyncio模块
   异步框架:sanic tronado twisted
      速度快！！！

import threading
import asyncio


@asyncio.coroutine
def hello():
    print('hello world %s'%threading.current_thread())
    yield from asyncio.sleep(1)  # 换成真正的IO操作
    print('hello world %s' % threading.current_thread())


loop = asyncio.get_event_loop()
tasks = [hello(),hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

六：四个IO模型对比

005

003

002

004

七：总结

网络并发知识点梳理：

1.软件开发架构	B/S；C/S

2.互联网协议
    OSI七层协议
    五层
    每一层都是干嘛的
        以太网协议	广播风暴
        IP协议

        TCP/UDP

3.三次握手、四次挥手

4.Socket简洁

5.TCP粘包问题	定制固定长度的包头

6.UDP协议

7.SocketServer模块

并发编程

1.操作系统发展史

2.多道技术

3.进程理论

4.开启进程的2种方式

5.互斥锁

6.生产者消费者模型

7.线程理论

8.开启线程的2种方式

9.GIL全局解释器锁

10.进程池 线程池

11.协程的概念

12.IO模型