WebServer -- 架构图 && 面试题(上)

????前言

????流程图 && 架构图

1）什么是 WebServer

2）服务器基本框架

3）Reactor && Proactor 模式

4）同步 I/O 模拟Proactor模式（Linux）

5）主从Reactor模式

6）并发模式中的同步读 && 异步读

7）半同步/半反应堆

8）半同步/半异步

9）解析报文（主从状态机 && 状态转移过程）

10）从状态机逻辑

11）响应报文

12）信号处理机制

13）日志系统

14）GET，POST 请求下页面跳转

15）架构图

16）源码目录解析

????面试题(上)

1）项目介绍

为什么要做 WebServer？

介绍下你的项目

2）线程池

手写线程池

线程同步机制有哪些

线程池中的工作线程是一直等待吗？

线程池中工作线程处理完一个任务后的状态是？

同时2000个客户端访问，线程数不多，如何及时响应？

一个请求占用线程很长事件，影响到了接下来的请求处理，如何解决

3）并发模型

服务器使用的并发模型是？

Reactor，Proactor，主从Reactor 模型的区别

为什么用 epoll，还有其他IO复用方式吗，区别是

????前言

本项目即将结束，手敲 14 篇万字博客，画了 20 多个流程图，整理了 40 多道相关八股

最后3篇博客：架构图 && 面试题(上)，面试题(下) && 八股(上)，八股(下)

????流程图 && 架构图

所有图我都画了一遍，然后，结合画的图，对照着看一遍源码的实现

（实际上，就是对照着流程图，回顾前面写过的博客，将每一个接口联系起来）

Excalidraw | Hand-drawn look & feel • Collaborative • Secure

哈哈哈，回看之前，自己亲手写的 11 篇博客，敲代码过程中的困惑也慢慢解开，融会贯通的感觉

1）什么是 WebServer

2）服务器基本框架

3）Reactor && Proactor 模式

4）同步 I/O 模拟Proactor模式（Linux）

5）主从Reactor模式

6）并发模式中的同步读 && 异步读

7）半同步/半反应堆

8）半同步/半异步

9）解析报文（主从状态机 && 状态转移过程）

10）从状态机逻辑

11）响应报文

12）信号处理机制

13）日志系统

14）GET，POST 请求下页面跳转

15）架构图

16）源码目录解析

每个目录，我会结合（README 和架构图）进行解析

总目录

总目录，我将它拆成上下两部分????

CGImysql: 处理  MySQL数据库  相关的 CGI 程序

http: 处理  HTTP 请求和响应

lock: 实现  锁机制 ，确保线程安全

log: 实现 日志系统，记录服务器的运行状态

root: 服务器的根目录，存放网站的 静态资源文件，用于构建用户界面

test_pressure: 压力测试

threadpool: 实现 线程池

timer: 定时器

LICENSE: 许可证文件，规定使用该项目的条款

README.md: 项目的说明文档

build.sh: 构建项目的脚本

config.cpp 和 config.h: 存放 配置信息 的代码文件

main.cpp: 主程序 入口文件

makefile: 用于 编译链接项目 的 Makefile 文件

webserver.cpp 和 webserver.h: 包含 Web服务器 的主要逻辑代码

http -- I/O处理单元

CGImysql -- 数据库连接

log -- 日志系统

lock -- 锁机制

timer -- 定时器处理非活动连接

CGImysql

校验 && 数据库连接池

数据库连接池

单例模式，保证唯一

list 实现连接池

连接池为静态大小

互斥锁实现线程安全

校验

HTTP请求采用POST方式

登录用户名和密码校验

用户注册及多线程安全

http

http 连接处理类

根据状态转移，通过主从状态机封装了 http连接类

其中，主状态机在内部调用从状态机，从状态机将处理状态和数据传给主状态机

客户端发出 http 连接请求

从状态机读取数据，更新自身状态和接受数据，传给主状态机

主状态机根据从状态机状态，更新自身状态，决定响应请求还是继续读取

lock

线程同步机制包装类

多线程同步，确保任一时刻只能有一个线程进入关键代码段

信号量

互斥锁

条件变量

log

同步/异步日志系统

同步 / 异步日志系统主要涉及两个模块，一个是日志模块，一个是阻塞队列模块

加入阻塞队列模块的目的：实现异步写入日志

自定义阻塞队列

单例模式创建日志

同步日志

异步日志

实现按天，超行分类

root

界面跳转

对 html 中的 action 行为设置标志位，将 method 设置为 POST

0 注册

1 登录

2 登陆检测

3 注册检测

5 请求图片

6 请求视频

7 关注我

test_pressure

服务器压力测试

（1）

（2）

（3）

webbench -- 网站压测工具

测试相同硬件不同服务的性能 && 不同硬件同一个服务的运行状况

展示服务器的两项内容：每秒响应请求数 && 每秒传输数据量

threadpool

半同步 / 半反应堆线程池

使用一个工作队列，完全解除了主线程和工作线程的耦合关系：

主线程往工作队列插入任务，工作线程通过竞争来取得任务并执行它

同步 IO 模拟 proactor 模式

半同步 / 半反应堆

线程池

timer

定时器处理非活动连接

由于非活跃连接占用连接资源（占着茅坑不拉屎），严重影响服务器性能

通过实现一个服务器定时器，处理这种非活跃连接，释放连接资源

利用 alarm 函数，周期性地出发 SIGALRM 信号

该信号处理函数利用管道通知主循环，执行链表上的定时任务

统一事件源

基于升序链表的定时器

处理非活动连接

接着，重看一遍前面写过的博客（梳理逻辑，熟悉源码和接口<常见手撕>，为下一步搞定面试题做准备）

????面试题(上)

1）项目介绍

为什么要做 WebServer？

专业课学过C++，Linux，计网，Mysql等知识，所以想通过本项目巩固网络编程和Linux，将分散的知识串联起来，顺便入门服务器。

介绍下你的项目

该项目通过C++，在Linux环境下开发

使用webbench进行压力测试，达到上万并发量

引入定时器，处理非活跃连接，及时释放连接资源，提升性能

alarm 函数周期性触发 SIGALRM 信号，使用管道通知主循环执行定时任务，实现统一事件源和基于升序链表的定时器

采用线程池，半同步/半反应堆架构，解耦主线程和工作线程，提高并发处理能力
（因为主线程和工作线程之前有个工作队列，所以两者间没有耦合性）

引入同步/异步日志系统，实现异步写入日志功能

通过主从状态机封装 http 连接类，实现对 HTTP 请求的处理

实现数据库连接池，采用单例和互斥锁保证线程安全

CGImysql处理数据库连接，log模块记录日志，lock模块实现锁机制，timer模块处理非活动连接

还支持处理大文件（包括视频文件和图片）

同时支持Reactor和Proactor模式，ET / LT均支持

补充解释????

利用CGI与MySQL提升网站性能（cgimysql）-数据运维技术 (dbs724.com)

2）线程池

详情请看????

webserver 之线程同步 && 线程池（半同步半反应堆）-CSDN博客

手写线程池

a. 定义

线程处理函数 worker() 和执行任务函数 run() ---- 私有

只提供构造，析构，添加任务的公共接口

template<typename T>
class threadpol {
    public:
        // thread_num 线程数量
        // max_requests 请求数量（请求队列中 最多允许 && 等待处理）
        // connpool 数据库连接池 指针
        threadpool(connection_pool *connpool,
                   int thread_number = 8,
                   int max_request = 10000);
        ~threadpool();

        // 请求队列 插入任务请求
        bool append(T* request);

    private:
        // 工作线程运行的函数
        // 不断从工作队列取出任务 并执行
        static void *worker(void *arg); // 声明为 static 的原因，下面构造函数解释

        void run();

    private:
        int thread_number; // 线程数

        int m_max_requests; // 请求队列最大请求书

        pthread_t *m_threads; // 描述线程池的数组，大小 m_thread_num

        std::list<T *> m_workqueue; // 请求队列

        locker m_queuelocker; // 保护请求队列的互斥锁

        sem m_queuestat; // 是否有任务需要处理

        bool m_stop; // 结束线程
        
        connection_pool *m_connPool; // 数据库连接池
};

b. 构造

涉及线程池的创建和回收

pthread_create() 将类的对象作为参数，传递给静态函数 worker()

在静态函数引用这个独享，并调用其动态方法 run()

具体地，类对象传递时用 this 指针，传递给静态函数后，转换为线程池类，并调用私有 run()

template<typename T>
threadpool<T>::threadpool( connection_pool *connPool,
                           int thrad_number,
                           int max_requests) // 构造函数参数列表
                           :
                           m_thread_number(thread_number), // 线程数
                           m_max_requests(max_requests), // 最大请求数
                           m_stop(false), m_threads(NULL), // 结束线程 && 线程池数组
                           m_connPool(connPool) // 数据库连接池指针
{
    if (thread_number <= 0 || max_requests <= 0)
        throw std::exception();

    // 线程 id 初始化
    m_threads = new pthread_t[m_thread_number]; // 数组

    if (!m_threads)
        throw std::exception();

    for (int i = 0; i < thread_number; ++i) {
        // thread_create(线程标识符, 线程属性, worker()指针, worker()的参数)
        // 因为 worker指针，指向线程处理函数的地址，而且 worker() 作为类成员函数
        // 且指向threadpool对象的 this 指针，作为默认参数被传入 worker() 中
        // 此时会和 worker(void* arg) 的类型 void* 不匹配
        // 所以上面才将 worker() 声明为 static

        // 循环创建线程
        if (thread_create(m_threads + i, NULL, worker, this) != 0) {
            delete [] m_threads;
            throw std::exception();
        }

        // 线程分离后，不用单独回收工作线程，便于资源释放
        if (thread_detach(m_threads[i])) {
            delete [] m_threads;
            throw std::exception();
        }
    }

}

c. 析构

template<typename T>
threadpool<T>::~threadpool()
{
    delete[] m_threads;
}

d. append() 添加任务

list 容器 创建请求队列

向队列添加任务时，通过 互斥锁 保证线程安全

添加完毕后，通过 信号量 提醒 “有任务要处理”

最后注意线程同步 ↓↓↓

使用了互斥锁 m_queuelocker.lock() 和 m_queuelocker.unlock() 来保护对任务队列 m_workqueue 的访问，防止多个线程同时访问引起数据竞争。

使用信号量 m_queuestat.post() 来通知空闲线程有任务需要处理，避免了一个线程获取多个任务的情况，也确保每个任务都能得到及时处理

template<typename T>
bool threadpool<T>::append(T* request)
{
    m_queuelocker.lock(); // 关键代码段加锁

    // 根据硬件，预先设置请求队列最大值
    if (m_workqueue.size() > m_max_requests) {
        m_queuelocker.unlock();
        return false;
    }

    // 添加任务
    m_workqueue.push_back(request);
    m_queuelocker.unlock(); // 解锁

    // 信号量 提醒有任务处理
    m_queuestat.post();
    return true;
}

e. worker() 线程处理

内部访问私有函数 run()，完成线程处理要求

// 前面构造函数中 pthread_create 调用了 worker
template<typename T>
void* threadpool<T>::worker(void* arg)
{
    // 调用时 *arg 是 this
    // 所以该操作其实是获取 threadpool 对象地址

    // 参数强转线程池类，调用成员方法
    threadpool* pool = (threadpool*)arg;
    // 线程池每一个线程创建都会调用 run()，睡眠在队列中
    pool->run();
    return pool;
}

f. run() 执行任务

工作线程从请求队列取出某个任务进行处理，注意线程同步

// 线程池所有线程睡眠状态，等待请求队列新增任务
template<typename T>
void threadpool<T>::run()
{
    while (!m_stop) {
        // 信号量等待
        // m_queuestat 是否有任务需要处理
        m_queuestat.wait();

        // 被唤醒后先加互斥锁
        // m_workqueue 请求队列
        m_queuelocker.lock();

        if (m_workqueue.empty()) {
            m_queuelocker.unlock();
            continue;
        }

        // 请求队列取 第一个任务request
        // 任务从请求队列 删除
        T* request = m_workqueue.front();
        m_workqueue.pop_front();
        m_queuelocker.unlock();
        if (!request) continue;

        // 连接池取出一个 数据库连接
        request->mysql = m_connPool->GetConnection();

        // process(模板类中的方法，这里是 http 类) 进行处理
        request->process();

        // 数据库连接 放回连接池
        m_connPool->ReleaseConnection(request->mysql);
    }
}

线程同步机制有哪些

1）RAII

之所以把 RAII 加到线程同步机制里，因为它可以用来管理信号量，互斥量，条件变量等资源

RAII -- Resource Acquisition is Initialization，资源获取即初始化

资源与对象的生命周期绑定，构造函数分配资源，析构函数释放资源

比如智能指针

2）信号量（限制访问某个资源的线程数量）

a. sem_init() 初始化 信号量
 
b. sem_destory() 销毁 信号量
 
c. sem_wait() 原子操作方式，信号量 -1；信号量 == 0，sem_wait() 阻塞
 
d. sem_post() 原子操作方式，信号量 +1；信号量 > 0，唤醒调用 sem_post()的线程

信号量就像是一个可以控制进程访问共享资源的门禁系统。这个门禁系统支持两种操作????

等待 (P) 操作：当一个进程试图访问共享资源时（比如想要通过门禁进入），它首先检查信号量的值。如果信号量大于 0（门禁开着），那么进程可以顺利通过，同时信号量减一（门禁关闭）。但是，如果信号量等于 0（门禁关着，有其他进程在使用资源），进程必须等待（挂起执行），不能继续执行直到有其他进程释放资源（信号量增加）

信号 (V) 操作：当一个进程使用完共享资源时（比如离开了房间），它会执行信号操作。如果有其他进程因为等待资源而被挂起，那么这个信号会唤醒其中一个等待的进程，让其继续执行。否则，如果没有进程在等待资源，信号量会自增，表示资源又变得可用

3）条件变量（线程间通信；实现线程等待唤醒机制）

a. pthread_cond_init() 初始化
 
b. pthread_cond_destory() 销毁
 
c. pthread_cond_broadcast() 广播方式，唤醒所有等待目标条件变量的 线程
 
d. pthread_cond_wait() 等待目标条件变量
调用时，传入 mutex 参数 (加锁的互斥锁)
执行时，1) 调用线程 放入条件变量的 请求队列
       2) 互斥锁 mutex 解锁
       3) 函数返回 0 时，互斥锁再次被锁上
       4) 也就是说，函数内部，会有一次 解锁 和 加锁 操作

当一个线程调用 pthread_cond_wait() 等待目标条件变量时，它会将自己放入条件变量的请求队列中，并传入一个已经加锁的互斥锁（mutex参数）。接着，互斥锁会被解锁，让其他线程有机会操作共享资源。当函数返回 0 时，表示条件满足，此时会再次对互斥锁进行加锁操作，以确保线程安全地访问共享资源。因此，在 pthread_cond_wait() 函数内部会有一次解锁和加锁的操作，确保线程的正确执行顺序和共享资源的安全访问

4）互斥量（一次只允许一个线程访问资源）

即互斥锁：保护关键代码段，确保独占式访问

a. 进入关键代码段 -- 获得互斥锁并加锁

b. 离开关键代码段 -- 唤醒等待该互斥锁的线程

a. pthread_mutex_init() 初始化互斥锁
 
b. pthread_mutex_destory() 销毁互斥锁
 
c. pthread_mutex_lock() 原子操作方式，给互斥锁，加锁
 
d. pthread_mutex_unlock() 原子操作方式，给互斥锁，解锁

线程池中的工作线程是一直等待吗？

工作线程睡眠在工作队列上，当主线程将新任务添加到工作队列时，就会唤醒某个一直在等待的工作线程

该工作线程从队列中取出任务并执行，其他工作线程则继续睡眠在工作队列上

线程池中工作线程处理完一个任务后的状态是？

请求队列为空，则该线程进入线程池继续等待

队列不为空，就和其他线程一起竞争任务

同时2000个客户端访问，线程数不多，如何及时响应？

1，采用线程池

主线程与工作线程分离，使用线程池管理工作线程，避免主线程阻塞

考虑扩大线程池容量

线程池复用线程资源，避免频繁创建和销毁小城

2，采用 ET 模式和非阻塞 socket

ET模式和非阻塞socket，确保及时处理

通过 epoll 的EPOLLONESHOT特性，降低可读，可写和异常事件被触发次数

3，采用半同步/半异步并发模式

通过 Reactor 或 Proactor 模式，满足并发量要求

4，采用集群或者分布式

通过分布式，将大任务拆分成小任务，各节点协同完成

通过集群，增加服务器(节点)数量

什么是分布式，分布式和集群的区别又是什么？这一篇让你彻底明白！_什么叫分布式-CSDN博客

一个请求占用线程很长事件，影响到了接下来的请求处理，如何解决

采取异步非阻塞模式，接收到新的请求后，不立即处理，而是安排一个以后的时间再发起请求，并且继续执行当前请求

采取超时设置，对每个请求设置合理的超时时间，如果处理时间超过给定阈值，则取消该请求或返回超时错误信息，及时释放线程资源

采取断点续传，对任务进行分段处理，某个处理阶段完成后暂停任务，等待下一次触发继续处理

任务分片，长时间任务拆分成多个小任务，每个小任务完成后释放线程资源

补充理解

深入理解同步阻塞、同步非阻塞、异步阻塞、异步非阻塞_同步阻塞同步非阻塞异步阻塞异步非阻塞-CSDN博客

3）并发模型

服务器使用的并发模型是？

采用 半同步半反应堆 作为并发模型

以 Proactor 事件处理模式为例

主线程充当异步线程，负责监听所有 socket 上的时间和处理 I/O 操作

新请求到达时，主线程接收连接 socket，并注册读写时间到 epoll 内核事件表中

如果连接 socket 上有读写事件发生，主线程从 socket 上接收数据，并将数据封装成请求对象插入请求队列

所有工作线程睡眠在请求队列上，当有任务到来时，通过竞争(互斥锁)获得任务接管权

工作线程仅负责业务逻辑，比如处理客户请求；主线程与内核配合实现底层的异步 I/O 操作

总的来说

采用半同步半反应堆并发模型的 Proactor 事件处理模式，主线程负责底层 I/O 操作和事件监听，工作线程专注于业务逻辑处理，通过异步 I/O 实现高效并发处理

Reactor，Proactor，主从Reactor 模型的区别

先通过Java了解下主从Reactor????

Reactor(主从)原理详解与实现_主从reactor-CSDN博客

回答：

1，Reactor（事件来了，我通知你，你来处理）（我 -- 操作系统内核；事件 -- 新连接）

采用同步 I/O，负责监听文件描述符上是否有事件发生

主线程（I/O 处理单元）负责事件感知和通知工作线程（同步IO向应用程序通知的是IO就绪事件），将读写事件放入请求队列，并由工作线程完成实际的数据读写，接收新连接和处理客户请求

应用进程需要主动调用 read / write 方法，进行数据的读取和写入，处理过程是同步的

比如，快递员在楼下通知你快递送达，需要你自己下楼拿快递

2，Proactor（事件来了，我处理完，再通知你）

采用异步 I/O，只负责发起 I/O 操作，真正的 I/O 实现由操作系统处理

主线程和操作系统负责处理读写数据，接收新连接等 IO 操作，工作线程仅负责业务逻辑，如处理客户请求

应用进程无需主动发起读写操作，操作系统完成读写后，会通知应用进程直接处理数据（异步IO向应用程序通知的是IO完成事件）

比如，快递员将快递送达你家门口后，再通知你

3，主从Reactor模式

主反应堆线程，负责分发连接建立事件，已连接套接字上的 IO 事件，交给子反应堆线程处理

子反应堆线程数量，可以根据CPU核数来设置，负责具体的 I/O 事件处理

主反应堆线程，只负责调用 accept 获取已连接套接字，并将其分配给响应的子反应堆线程

结合了 Reactor 和 Proactor 的特点

概括地说，Reactor模式和Proactor模式都是基于事件分发的网络编程模式，区别在于 I/O 事件处理的方式

Reactor基于待完成的 I/O 事件，而Proactor基于已完成的 I/O 事件，主从Reactor结合了两者的优点

为什么用 epoll，还有其他IO复用方式吗，区别是

常用的是 select，poll，epoll，当然，这里会补充下对 io_uring 的说明

选择 epoll 从两点出发：

性能：
1）在文件描述符数量较多且活跃度不一的情况下，epoll 能提升性能
2）因为 epoll 将文件描述符维护在内核态，每次添加文件描述符，只需要执行一个系统调用
3）而且能够直接返回触发事件的文件描述符，避免了遍历整个文件描述符集合的性能损耗

数据结构：
1）select 使用线性表创建文件描述符集合，而且上限 1024
2）poll 使用链表
3）epoll 底层采用红黑树来构建，并维护一个 ready list，能够在 epoll_wait() 调用时，只观察已就绪事件
4）epoll 支持 LT 和 ET 两种工作模式，而 select 和 poll 只能工作在相对低效的 LT 下

区别是：

select, poll 都需要将文件描述符集合从用户态拷贝到内核态，而epoll只用拷贝需要修改的文件描述符，避免了集体拷贝的开销

select，poll 最大开销来自内核判断是否有文件描述符就绪，需要遍历整个文件描述符集合，而 epoll 直接返回触发事件的文件描述符

select, poll, epoll 都是同步 I/O，而 io_uring 是异步 I/O，它通过用户和内核之间的共享内存映射来避免数据拷贝，减少CPU开销，还支持事件批处理，降低系统调用次数和上下文切换的开销

下面介绍下 io_uring：

零拷贝：io_uring 通过共享内存映射来避免数据拷贝，将用户空间和内核空间之间的数据传输最小化

批处理：它还支持事件批处理，即一次性可以提交多个 I/O 请求给内核，减少系统调用和上下文切换的开销，提高吞吐量

Ring Buffer 机制：io_uring 使用环形缓冲区（ring buffer），作为用户和内核之间的通信机制。用户将 IO 请求放入Ring Buffer，内核会异步处理这些请求，并将结果返回到 Ring Buffer，用户再从 Ring Buffer 读取

高效的事件通知机制：使用 IO Completion Event（IO完成事件）机制，通过事件通知的方式告知用户空间 IO 操作的完成情况，避免用户频繁的轮询内核，提高响应速度

秒客网

WebServer -- 架构图 && 面试题(上)

????前言

????流程图 && 架构图

1）什么是 WebServer

2）服务器基本框架

3）Reactor && Proactor 模式

4）同步 I/O 模拟Proactor模式（Linux）

5）主从Reactor模式

6）并发模式中的同步读 && 异步读

7）半同步/半反应堆

8）半同步/半异步

9）解析报文（主从状态机 && 状态转移过程）

10）从状态机逻辑

11）响应报文

12）信号处理机制

13）日志系统

14）GET，POST 请求下页面跳转

15）架构图

16）源码目录解析

????面试题(上)

1）项目介绍

为什么要做 WebServer？

介绍下你的项目

2）线程池

手写线程池

线程同步机制有哪些

线程池中的工作线程是一直等待吗？

线程池中工作线程处理完一个任务后的状态是？

同时2000个客户端访问，线程数不多，如何及时响应？

一个请求占用线程很长事件，影响到了接下来的请求处理，如何解决

3）并发模型

服务器使用的并发模型是？

Reactor，Proactor，主从Reactor 模型的区别

为什么用 epoll，还有其他IO复用方式吗，区别是

相关文章

WebServer -- 架构图 && 面试题(上)

????前言

????流程图 && 架构图

1）什么是 WebServer

2）服务器基本框架

3）Reactor && Proactor 模式

4）同步 I/O 模拟Proactor模式（Linux）

5）主从Reactor模式

6）并发模式中的 同步读 && 异步读

7）半同步/半反应堆

8）半同步/半异步

9）解析报文（主从状态机 && 状态转移过程）

10）从状态机逻辑

11）响应报文

12）信号处理机制

13）日志系统

14）GET，POST 请求下页面跳转

15）架构图

16）源码目录解析

????面试题(上)

1）项目介绍

为什么要做 WebServer？

介绍下你的项目

2）线程池

手写线程池

线程同步机制有哪些

线程池中的工作线程是一直等待吗？

线程池中工作线程处理完一个任务后的状态是？

同时2000个客户端访问，线程数不多，如何及时响应？

一个请求占用线程很长事件，影响到了接下来的请求处理，如何解决

3）并发模型

服务器使用的并发模型是？

Reactor，Proactor，主从Reactor 模型的区别

为什么用 epoll，还有其他IO复用方式吗，区别是

相关文章

6）并发模式中的同步读 && 异步读