IO模型

• 阻塞IO
• 非阻塞IO
• IO复用
• 信号驱动IO：适合需要异步IO通知的场景，可以提高并发能力
• 异步IO

服务器处理多个请求

• 单线程web
• 多线程web
• IO多路复用web
• 多路复用多线程

IO多路复用

IO多路复用解决什么问题： 服务器为每个客户端连接创建一个进程/线程，消耗的资源很多。IO多路复用可以用一个进程/线程处理多个TCP连接，减少系统开销。 复用一个线程，处理多个socket内的事件，减少线程上下文切换

网络通讯中的事件

读事件

1. 已连接队列中有新的socket
2. 接受缓存中有数据可以读
3. tcp连接已断开

写事件

1.发送缓冲区没有满，可以写入数据

常见的多路复用模型

SELECT（1024）

bitmap

SELECT 底层存放 socket 的结构 fd_set 是一个1024位的bitmap(int[32] 4字节 * 8位 *32个 = 1024) FD_ZERO(fd_set *set)//位图置0 FD_CLR(fd,fd_set)//删除某socket FD_ISSET(fd,fd_Set)//判断socket是否在bitmap中 FD_SET(fd,fd_set)//socket加入集合

实例

int main() {
    fd_set readfds;

    FD_ZERO(&readfds);

    // 假设要监听标准输入
    FD_SET(STDIN_FILENO, &readfds);

    printf("等待输入...\n");

    int ret = select(STDIN_FILENO + 1, &readfds,NULL,NULL,NULL);//第二个参数为读事件，第三个参数为写事件

    if (ret < 0) {
        perror("select");
        return 1;
    }

    if (FD_ISSET(STDIN_FILENO, &readfds)) {
        printf("标准输入有数据了\n");
    }

    return 0;
}

水平触发

被Select监视的socket上发生事件时，select会立即返回，通知程序处理事件，如果事件没有被处理，不会丢失，再次调用select的时候会再次通知。

性能

1s大概12万请求

问题

1. 采用轮询遍历bitmap，数据多时性能下降
2. 每次调用select的时候要拷贝bitmap，因为select会修改bitmap
3. 程序运行在用户态，在内核运行select的时候，要把bitmap从用户态拷贝到内核态
4. bitmap大小有限，增加数量效率会下降

POLL（数千）

结构

用结构体数组存放socket

  struct pollfd {
               int   fd;         /* 为-1则忽略*/
               short events;     /* 需要监视的事件 */
               short revents;    /* 返回的事件 */
           };

POLL的数据： POLLIN 有事件可以读 POLLOUT 有事件可以写 等…

实例

int main() {
    struct pollfd fds[1];

    // 监听标准输入
    fds[0].fd = STDIN_FILENO;
    fds[0].events = POLLIN;

    printf("等待输入...\n");

    int ret = poll(fds, 1, -1);

    if (ret < 0) {
        perror("poll");
        return 1;
    }

    if (fds[0].revents & POLLIN) {
        printf("标准输入有数据了\n");
    }

    return 0;
}

水平触发

问题

1. Poll的结构体数组传入内核后转换为链表
2. 每调一次拷贝一次（select拷贝两次
3. 底层仍是遍历，socket越多开销越大

EPOLL（百万）

结构

 struct epoll_event {
           uint32_t      events;  /* epoll事件 */
           epoll_data_t  data;    /* 事件数据 */
       };

       union epoll_data {
           void     *ptr;
           int       fd;
           uint32_t  u32;
           uint64_t  u64;
       };

       typedef union epoll_data  epoll_data_t;//联合体

EPOLLIN 读事件 EPOLLOUT 写事件

实例

int main() {
    // 1. 创建 epoll 实例，这里返回的是一个整数值
    //代表一个eventpoll模型描述符，也是用来存储全部事件的红黑树的根
    //参数原本指可以容纳的文件描述符的最大个数
    //更新后无实际意义，只是为了向前版本兼容
    //epollwait里的maxevents参数没有必要和这个参数进行比较

    int epfd = epoll_create1(0);

    // 2. 创建要监听的事件
    struct epoll_event event;
    event.events = EPOLLIN;//要监视的事件类型
    event.data.fd = STDIN_FILENO;//指定什么返回什么类型

    // 3. 把 需要监视的事件加入 epoll
    epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &event);

    // 4. 存放返回的事件
    struct epoll_event events[10];

    // 5.等待事件发生
    int n = epoll_wait(epfd, events, 10, -1);

    // 6.返回要处理的事件的数量
    for (int i = 0; i < n; i++) {
        if (events[i].events & EPOLLIN) {
            printf("stdin 有数据可以读取\n");
        }
    }

    close(epfd);

    return 0;
}

阻塞IO和非阻塞IO

**阻塞：**在进程/线程发起调用，等待调用返回时，进程/线程会阻塞等待。等待中的进程/线程让出CPU的使用权 **非阻塞：**在进程/线程中，发起一个调用会立刻返回 connect，accept，send，recv会阻塞 传统网络模型中，每线程阻塞 IO复用中，事件循环不能被阻塞在任何环节要采用非阻塞 例如：对非阻塞IO的 connect() 进行调用，不管握手结果是成功或者失败，都会先返回失败。如果connect() 返回的 fd 可写，那么可以认为连接成功

水平触发和边缘触发

//设置边缘触发，默认为水平触发
ev.event = EPOLLIN | EPOLLET 

水平触发 LT

读：epoll_wait触发读事件，如果程序没有把数据读完。再次调用epoll_wait的时候，将立即再次触发读事件 写：发送缓冲区没有满，表示还可以写入数据。再次调用epoll_wait的时候，再次触发写事件。

边缘触发 ET

读：epoll_wait触发读事件之后，不管程序有没有处理，都不会再触发读事件，只有新的数据到达的时候，才会再次触发读事件。 写：epoll_wait触发写事件之后，如果发送缓冲区未满，不会触发写事件。只有缓冲区状态由满变为不满的时候，才会再次触发写事件。

原理

首先调用epoll_create1(0)，返回一个整数值代表event模型占用的模型描述符-也是用来存储全部事件的红黑树的根，以及创建一个存放就绪事件的双端队列 红黑树的本质就是告诉内核需要监听哪些文件描述符上面的哪些事件，就绪队列管理已经就绪的fd epoll感知事件到来不采用轮询，调用epoll_ctl方法，向内核注册fd和相关事件的时候同时注册一个回调函数。 当epollitem对应的文件描述符上的事件已经就绪的时候，回调函数就会将该节点连接到已经就绪的双端队列中(不是拷贝一份) 调用epoll_wait方法，判断就绪队列中哪些文件描述符上的哪些事件就绪了

Questions

Q：EPOLL 为什么使用红黑树 而不是Hash 或者 B+树？

A：

1. epoll 需要频繁地对 fd 进行添加、删除、修改和查找，红黑树能在这些操作上都提供稳定的 O(log n) 性能，同时实现成熟、内核开销适中。
2. Hash 虽然平均 O(1)，但不适合 epoll 对有序性和稳定最坏情况的要求。
3. B+ 树主要适合磁盘/页式存储场景，在内存中的内核 fd 管理场景下没有必要。

Q:EPOLL为什么比SELECT和POLL快？

A:

1. Epoll只在调用 epoll_ctl方法 即监听事件的时候才会把数据从用户态拷贝到内核态，一次拷贝。而SElECT 和 POLL每执行都需要将数据从用户态拷贝到内核态
2. EPOLL在调用epoll_wait的时候只会拷贝已经就绪的事件，不会拷贝没有就绪的事件
3. 在判断事件是否就绪时，采用回调机制而不是轮询，epoll_wait不需要循环检查，只需要访问已就绪的双端队列，就可以找到已就绪的事件。这个过程的时间复杂度 O(1)

Q:EPOLL 一定比 POLL 快吗？

A:在并发数可控的时候，遍历结构体的开销较小，此时POLL更快。EPOLL适用于高并发网络场景。 收起

slice和数组

Slice的底层是数组

• 数组大小是数组类型的一部分。[3]int和[4]int是两种不同类型的数组。数组是值类型，作为参数传递的时候会传递整个数组。数组需要指定大小，不指定则自动推算初始化大小。

• Slice的底层也是数组，描述了底层数组的一个片段，包括指向数组的指针，容量和长度。切片在参数传递的时候按值传的是包含底层数组长度，容量，指针的副本，副本中的指针指向同一底层数组，所以在函数内，对底层数组的修改对调用函数方可见。切片可以通过数组或者make初始化

slice的扩容原则

1.18之后

当slice容量小于256，则扩容为之前的2倍，若slice容量超过256，新容量公式old+（old+3*256）/4 自动扩容 收起

Go 语言

并发和并行

并发：两个线程交替推进，看起来同时执行。

并行：两个线程在不同 CPU 核心上真正同时执行。

进程、线程和协程的区别

进程是操作系统进行资源分配和调度的基本单位，线程是 CPU 调度和执行的基本单位 同一进程内的线程共享一片进程的内存空间和大部分资源，但是拥有独立的栈，寄存器和程序计数器

• 进程： 进程是具有一定独立功能的程序，是资源调度和分配的最小单位。每个进程都有自己独立的内存空间，不同进程通过进程间通信来通信。由于进程比较重，占据独立的内存，所以上下文间的切换开销比较大(栈，寄存器，虚拟内存)，但是相对比较稳定安全。

• 线程： 线程是进程的实体，内核态，是 CPU 调度和执行的基本单位，是比进程更小的有独立功能的基本单位，线程间通信通过共享内存，上下文切换很快，资源开销比较小。相比进程不够稳定，容易丢失数据

• 协程： 协程是一种用户态的轻量线程。通常由程序而不是操作系统调度。协程有自己的上下文寄存器和栈。协程调度切换的时候，把上下文，寄存器和栈保存到别的地方，协程切换回来的时候，从别的地方恢复上下文寄存器和栈。直接操作栈则没有内核的切换开销，可以不加锁的访问全局变量，故上下文切换非常快

GMP模型

goroutine 如何调度到线程上

-G 是 goroutine，表示具体的执行任务；

-M 可以理解为 Go runtime 管理的操作系统线程，真正负责执行代码；

-P 是调度器运行所需要的处理器资源，保存调度相关的状态和本地运行队列。 GOMAXPROCS 决定同时有多少个 P 可以执行 Go 代码，例如 GOMAXPROCS=2 时，最多有两个 P 同时运行 Go 代码，P 会绑定到 M 上，由 M 执行 P 当前调度的 G。大量 G 可以被少量 M 和 P 调度执行，所以 goroutine 并不是一个 goroutine 对应一个操作系统线程。

工作流程：

一个 goroutine 创建之后，会进入 runnable 状态，通常先放到当前 P 的本地运行队列，也可能进入全局队列。M 获取一个 P，然后从 P 的本地队列中取出 G 执行。如果本地队列没有 G，还可以从全局队列或者其他 P 的队列中获取任务，这就是 work stealing。

阻塞 Handoff

如果 G 在执行过程中发生普通的 goroutine 阻塞，比如等待 channel、锁等，G 会进入 waiting 状态，当前 M 可以继续调度其他 runnable G，不需要阻塞整个线程。

如果 G 发生阻塞的系统调用，情况有所不同。G 会进入 syscall 状态，M 可能被操作系统阻塞。runtime 会通过 entersyscall 等机制让当前 P 与这个执行 syscall 的 G/M 脱离绑定，使 P 可以被其他 M 获取。其他 M 获取 P 后，就可以继续执行这个 P 上其他 runnable 的 G。

当 syscall 返回时，G 进入 exitsyscall 流程，runtime 会尝试让这个 G 重新获得一个 P。如果有空闲 P，就可以重新绑定 P 并继续执行；如果暂时没有可用的 P，这个 G 会进入 runnable 状态，等待之后重新调度，而执行 syscall 的 M 也可能继续参与调度或者进入空闲状态

工作窃取

当某个 P 的本地运行队列没有可执行的 G 时，它会尝试从其他 P 的本地运行队列中“偷”一部分 G 来执行，从而提高 CPU 利用率、减少某些 P 空闲而其他 P 忙碌的情况。

抢占调度

当一个 G 长时间占用 CPU、不主动让出执行权时，Go runtime 可以强制让它暂停，把 CPU 执行机会交给其他 runnable 的 G，避免一个 G 长时间霸占 P。

值传递

Go 只有值传递

• 值传递：函数拿到的是数据的一份副本；

• 引用传递：函数拿到的是对原数据的引用/别名，因此可以直接修改原数据。

defer机制

defer的执行顺序和调用顺序相反 当defer语句被执行的时候，defer后面的语句会被延迟执行直到包含defer的函数执行完，不论函数是正常return还是panic，当一个函数中有多个defer语句的时候，他们的执行顺序和声明顺序相反

逃逸机制

栈和堆都是虚拟地址空间中的内存区域 栈主要存放函数调用相关时的局部变量，参数，返回地址，以及不逃逸的局部变量，在进入函数时创建栈帧。函数返回后，这个栈帧就会被回收。所以栈的生命周期和函数调用有关，分配和释放非常快。 堆用于存放动态分配且生命周期可能超过当前函数的数据。当程序需要动态申请内存的时候，一般从堆中分配。堆中的数据需要显式释放或者由GC等机制管理。 Go的编译器会分析这个变量的生命周期是否可能超过当前函数的栈帧，以及是否存在其他导致他逃逸的情况，如果不逃逸可以放到栈上，反之放到堆上

make和new

make和new都是用于初始化的函数

• make用于初始化并分配内存，只能用来创建map，channel，slice，返回的是创建后的数据结构
• new只用于分配内存但不初始化，返回的是指向该内存的指针

为什么 nil slice 可以 append，而 nil map 不能直接赋值？

nil slice 的 append 可以让 Go 重新分配/建立底层数组；nil map 没有可用于写入的哈希表结构，所以直接赋值会 panic。nil map不会自动初始化底层的哈希表。 收起