网络编程需要处理的内容

1. 连接建立
2. 连接断开
3. 消息到达
4. 消息发送

网络IO职责

• 所有的IO系统调用都有两个职责，一个是操作IO，另一个是检测IO
• IO多路复用只能检测IO，只有IO函数能操作IO

检测IO

• 角色定义：client、server、mysql（代指第三方服务）
• fd定义：listenfd（服务端监听端口）、clientfd（accept客户端后分配fd）、connectfd（连接第三方建立fd）

连接建立

1. 接收连接（与客户端）

• 方式：使用bind、listen监听
• 监听内容：listenfd的读事件
• 原理：

  1 2 3

  客户端发送SYN 给 服务端 服务端返回ACK 给 客户端 （此时生成一个半连接队列的TCB） 等到客户端返回的ACK 到达 服务端 （此时将tcb move到全连接队列，取tcb的内容生成一个clientfd，返回listenfd读事件就绪）

2. 主动连接（与第三方服务）

• 方式：使用connect连接第三方
• 监听内容：connectfd的写事件
• 原理：

  1 2	服务端发送SYN 给第三方 服务端收到ACK ，此时就返回connectfd写事件就绪

连接断开

1. 主动断开

• 方式：close、shutdown
• 可以只关闭读端（有一些实际用处）、也可以同时关闭读写端

2. 被动断开

• 方式：read = 0、write = -1 && errno = EPIPE

3. 检测

• EPOLLRDHUP（服务端读端关闭）
• EPOLLHUP（服务端读写都关闭）

消息到达

• 监听内容：clientfd的读事件、EPOLLIN
• 原理：内核空间中的read buffer有数据时，触发clientfd的读事件就绪，需要将数据从内核态拷入用户态的后续操作

消息发送

• 监听内容：clientfd的写事件
• 原理：内核空间中的write buffer有可写空间时，触发clientfd的可写事件就绪，需要将数据从用户态拷入内核态的后续操作
• why监听写事件：通常write操作不能将全部的数据写入write buffer，需要监听可写事件，将剩余数据继续写入

操作IO

阻塞IO与非阻塞IO

• 阻塞在网络线程；
• 连接的 fd 阻塞属性决定了 io 函数是否阻塞；
• 具体差异在：io 函数在数据未到达时是否立刻返回；

IO多路复用

• Why IO多路复用：因为IO函数只能检测一条连接的就绪状态，如果想要检测多条连接，只能（1）使用多线程+阻塞IO，（2）使用轮训+非阻塞IO，以上都非常消耗资源
• io 多路复用只负责检测 io，不负责操作 io；
• int n = epoll_wait(epfd, evs, sz, timeout);
• timeout = -1 一直阻塞直到网络事件到达；
• imeout = 0 不管是否有事件就绪立刻返回；
• timeout = 1000 最多等待 1 s，如果1 s内没有事件触发则返回；

• epoll一般是一个线程一个epoll，即One eventloop per thread

Why IO多路复用搭配非阻塞IO

1. 多线程环境中

• 场景：将一个listenfd放到多个线程的epoll中处理，当一个连接到达时，其中一个epoll正确触发完成了accept，此时其他的线程中的accept会阻塞住。

2. 边缘触发下

• 场景：在使用边缘触发的epoll中，只有当文件描述符再一次有可读事件时，它才会触发可读就绪，read在一次事件循环中把read buffer读空后会阻塞。

1. select bug

• 当一个数据到达时，select会报告读事件，但是这个数据可能没有经过校验和检测所以被丢弃了，而select已经上报了事件，如果使用阻塞IO，read将会阻塞住。

IO多路复用搭配阻塞IO例子

• MySQL，select接受连接，每个连接一个线程
• libevent，可以加一个系统调用，看缓冲区有多少数据

Reactor编程

• Reactor把io的处理转化为对事件的处理

1. 注册io就绪事件 注册io多路复用中 事件 包含callback 在callback中操作具体io
2. epoll_wait收集事件 处理事件、循环事件

连接建立

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 一、处理客户端的连接
// 1. 注册监听 listenfd 的读事件
struct epoll_event ev;
ev.events |= EPOLLIN;
epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &ev);
// 2. 当触发 listenfd 的读事件，调用 accept 接收新的连接
int clientfd = accept(listenfd, addr, sz);
struct epoll_event ev;
ev.events |= EPOLLIN;
epoll_ctl(efd, EPOLL_CTL_ADD, clientfd, &ev);
// 二、处理连接第三方服务
// 1. 创建 socket 建立连接
int connectfd = socket(AF_INET, SOCK_STREAM, 0);
connect(connectfd, (struct sockaddr *)&addr,sizeof(addr));
// 2. 注册监听 connectfd 的写事件
struct epoll_event ev;
ev.events |= EPOLLOUT;
epoll_ctl(efd, EPOLL_CTL_ADD, connectfd, &ev);
// 3. 当 connectfd 写事件被触发，连接建立成功
if (status == e_connecting && e->events & EPOLLOUT) {
    status == e_connected;
    // 这里需要把写事件关闭
    epoll_ctl(epfd, EPOLL_CTL_DEL, connectfd, NULL);
}

连接关闭

1
2
3
4
5
6
7
8
9

if (e->events & EPOLLRDHUP) {
    // 读端关闭
    close_read(fd);
    close(fd);
}
if (e->events & EPOLLHUP) {
    // 读写端都关闭
    close(fd);
}

消息到达

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// reactor 要用非阻塞io
// select
if (e->events & EPOLLIN) {
    while (1) {
        int n = read(fd, buf, sz);
        if (n < 0) {
            if (errno == EINTR)
                continue;
            if (errno == EWOULDBLOCK)
                break;
            close(fd);
        } else if (n == 0) {
            close_read(fd);
            // close(fd);
        }
        // 业务逻辑了
    }
}

消息发送完毕

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

int n = write(fd, buf, dz);
if (n == -1) {
    if (errno == EINTR)
        continue;
    if (errno == EWOULDBLOCK) {
        struct epoll_event ev;
        ev.events = EPOLLOUT;
        epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
        return;
    }
    close(fd);
}
// ...
if (e->events & EPOLLOUT) {
    int n = write(fd, buf, sz);
    //...
    if (n == sz) {
        epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
    }
}

Reactor网络模块与业务模块的关系

• 黄色部分为业务模块

Reactor应用与优化

Redis

• 环境：

1. kv、数据结构、内存数据库
2. 命令处理是单线程的

• 单reactor模型

1. 在单线程Reactor模型中，读数据、写数据、执行命令都在同一个线程中，整个框架十分简单清晰，且没有数据竞争问题，对两个buffer的操作不用加锁。单线程的缺点也很明显，“不能同时做两件事”，处理网络IO时不能执行命令，执行命令时不能处理网络IO。

• why 单线程 reactor

1. 单线程的业务逻辑。由于Redis的操作是内存操作，处理命令的过程通常不是瓶颈。
2. 操作具体命令时间复杂度低
3. 加锁困难，如果硬要把处理命令的部分变为多线程，那么在处理过程中会需要频繁用锁来解决并发问题，可能得不偿失。

• 问题：单线程Reacotr，执行命令需要等待前一个命令执行完成才可以响应。Redis的瓶颈在网络数据处理。
• 解决问题：IO操作分线程池处理（主线程先等待有io就绪事件，然后分发给io多线程去完成全部的io操作，进入主线程单线程一条一条执行指令，结果先写入缓冲区，然后分发给io多线程去完成io操作）、compute操作进行分治算法优化、采用不同数据结构实现相同的对象模型

memcached

• 环境：

1. kv内存数据库
2. 多线程处理命令

• Why 多线程 reactor

1. kv操作简单
2. 更高并发度处理业务
3. 加锁容易

ngix

• 环境

1. 反向代理
2. 多进程处理业务

• Why 多进程 reactor

1. 业务类型复杂
2. 通过进程隔离运行环境避免加锁
3. 请求间比较独立

• 解决问题：

1. 通过锁在用户态解决竞争，目的是为了用户层处理连接的负载均衡
2. 进程达到7/8*connectiongs的时候，不再处理连接，让其他进程处理连接
3. 当所有进程达到7/8*connectiongs的时候，连接处理将变得缓慢