告别纸上谈兵！动手攻克服务器百万级并发

在互联网高速发展的今天，百万级并发已成为许多高流量应用的标配。

无论是电商平台的秒杀活动、社交平台的实时消息推送，还是物联网海量设备接入，都需要服务器能够同时处理海量连接。

本文将带你一步步实现一个基于C++的百万级并发服务器原型。

Part1前置知识

在写代码前，必须先搞懂两个核心问题：高并发的瓶颈在哪？为什么选择 “epoll + 线程池”？

1.1、核心瓶颈：文件描述符与 IO 模型

文件描述符（FD）限制：Linux 中一切皆文件，Socket 连接本质是 “网络文件”，对应一个 FD。默认单个进程的 FD 上限仅 1024，这是百万并发的第一道坎，必须先突破。

IO 模型的选择：

• 同步 IO（阻塞 / 非阻塞）：传统 “一个连接一个线程” 会导致线程数爆炸（百万连接需百万线程），上下文切换开销极高。异步 IO（Linux AIO）：成熟度低，实操中较少用于核心业务。
• 多路复用（epoll/select/poll）：通过一个线程监听大量 FD 的 IO 事件，仅当 FD 活跃（如可读 / 可写）时才处理，是高并发的最优选择。

1.2、epoll：为什么是它？

相比 select/poll，epoll 有三大核心优势，直接解决高并发场景的痛点：

• 水平触发（LT）：只要 FD 有数据未处理，就会持续触发事件（适合新手，不易丢数据）。
• 边缘触发（ET）：仅在 FD 状态变化时触发一次（需一次性读 / 写尽数据，效率更高，本文选用）。

1.3、架构选型：Reactor 模式 + 线程池

本文采用 Reactor 反应器模式，核心分工：

• epoll：作为 “事件反应器”，监听 FD 的 IO 事件（如连接、读、写）。
• 线程池：作为 “任务处理器”，处理 epoll 分发的业务逻辑（如解析请求、生成响应），避免频繁创建线程的开销。

Linux教程

分享Linux、Unix、C/C++后端开发、面试题等技术知识讲解

Part2系统配置调优

不做系统调优，代码写得再好也无法支撑百万并发 —— 这是很多新手踩的第一个坑。我们需要突破 FD 限制和 TCP 连接瓶颈。

2.1、突破文件描述符（FD）限制

1）. 临时修改（当前会话生效）

# 查看当前 FD 上限（默认 1024）
ulimit -n
# 临时设置为 100 万（重启终端后失效）
ulimit -n 1000000

2）. 永久修改（重启后生效）

编辑 /etc/security/limits.conf，在末尾添加（所有用户生效）：

* soft nofile 1000000  # 软限制（警告阈值）
* hard nofile 1000000  # 硬限制（强制上限）
root soft nofile 1000000
root hard nofile 1000000

编辑 /etc/sysctl.conf，添加系统级 FD 上限：

# 系统总 FD 上限
fs.file-max = 1000000
# 单个进程最大 FD 上限（与 limits.conf 对应）
fs.nr_open = 1000000

执行命令使配置生效：

sysctl -p

2.2、TCP 协议调优（提升连接稳定性与吞吐量）

继续在 /etc/sysctl.conf 中添加以下配置，解决 TCP 连接队列溢出、缓冲区不足等问题：

# 1. TCP 缓冲区配置（接收/发送缓冲区，单位：字节）
net.ipv4.tcp_rmem = 4096 87380 16777216  # 最小4K，默认85K，最大16M
net.ipv4.tcp_wmem = 4096 16384 16777216  # 最小4K，默认16K，最大16M
# 2. 连接队列调优（避免半连接/全连接队列溢出）
net.ipv4.tcp_max_syn_backlog = 65536  # 半连接队列（SYN_RCVD 状态）上限
net.core.somaxconn = 65536            # 全连接队列（ESTABLISHED 状态）上限
net.core.netdev_max_backlog = 65536    # 网卡接收队列上限（避免数据包丢失）
# 3. TIME_WAIT 优化（减少连接建立耗时）
net.ipv4.tcp_tw_reuse = 1  # 允许复用 TIME_WAIT 状态的 Socket
net.ipv4.tcp_fin_timeout = 30  # TIME_WAIT 超时时间（默认60s→30s）
net.ipv4.tcp_tw_recycle = 0  # 关闭 TIME_WAIT 快速回收（高并发下易丢包）

执行 sysctl -p 生效，至此系统层面的瓶颈已突破。

Part3基础版服务器实现

先实现基础版服务器（epoll + 线程池），后续基于此代码进行四大优化。

我们将服务器拆分为 4 个模块：线程池（处理业务）、epoll 管理器（监听事件）、TCP 服务器（连接与数据处理）、主函数（整合启动）。

3.1、模块 1：线程池实现（thread_pool.h）

线程池的核心是 “预创建线程 + 任务队列”，避免频繁创建 / 销毁线程的开销。使用互斥锁保护任务队列，条件变量唤醒空闲线程。

#ifndef THREAD_POOL_H
#define THREAD_POOL_H
#include <pthread.h>
#include <queue>
#include <functional>
#include <iostream>
class ThreadPool {
public:
    // 构造：初始化核心线程数
    ThreadPool(int core_threads) : core_threads_(core_threads), stop_(false) {
        // 初始化互斥锁和条件变量
        pthread_mutex_init(&mutex_, nullptr);
        pthread_cond_init(&cond_, nullptr);
        // 预创建核心线程
        for (int i = 0; i < core_threads_; ++i) {
            pthread_t tid;
            pthread_create(&tid, nullptr, thread_func, this);
            threads_.push_back(tid);
        }
    }
    // 析构：停止线程池
    ~ThreadPool() {
        stop_ = true;
        pthread_cond_broadcast(&cond_);  // 唤醒所有等待线程
        for (auto tid : threads_) {
            pthread_join(tid, nullptr);  // 等待线程退出
        }
        // 释放资源
        pthread_mutex_destroy(&mutex_);
        pthread_cond_destroy(&cond_);
    }
    // 向队列添加任务
    void add_task(std::function<void()> task) {
        pthread_mutex_lock(&mutex_);
        tasks_.push(task);
        pthread_cond_signal(&cond_);  // 唤醒一个空闲线程
        pthread_mutex_unlock(&mutex_);
    }
private:
    // 线程函数（静态函数，通过 this 访问类成员）
    static void* thread_func(void* arg) {
        ThreadPool* pool = static_cast<ThreadPool*>(arg);
        while (!pool->stop_) {
            pthread_mutex_lock(&pool->mutex_);
            // 任务队列为空时，阻塞等待
            while (pool->tasks_.empty() && !pool->stop_) {
                pthread_cond_wait(&pool->cond_, &pool->mutex_);
            }
            // 线程池停止，退出循环
            if (pool->stop_) {
                pthread_mutex_unlock(&pool->mutex_);
                break;
            }
            // 取出任务并执行
            auto task = pool->tasks_.front();
            pool->tasks_.pop();
            pthread_mutex_unlock(&pool->mutex_);
            task();  // 执行具体业务（如处理客户端数据）
        }
        return nullptr;
    }
private:
    int core_threads_;                  // 核心线程数
    bool stop_;                         // 线程池停止标志
    std::vector<pthread_t> threads_;    // 线程列表
    std::queue<std::function<void()>> tasks_;  // 任务队列
    pthread_mutex_t mutex_;             // 保护任务队列的互斥锁
    pthread_cond_t cond_;               // 唤醒线程的条件变量
};
#endif // THREAD_POOL_H

3.2、模块 2：epoll 管理器（epoll_manager.h）

封装 epoll 的创建、事件注册、事件等待与分发，简化上层调用。

#ifndef EPOLL_MANAGER_H
#define EPOLL_MANAGER_H
#include <sys/epoll.h>
#include <vector>
#include <iostream>
#include <unistd.h>
#include "thread_pool.h"
class EpollManager {
public:
    // 构造：关联线程池
    EpollManager(ThreadPool* thread_pool) : thread_pool_(thread_pool) {
        // 创建 epoll 实例（EPOLL_CLOEXEC：进程退出时自动关闭 FD）
        epoll_fd_ = epoll_create1(EPOLL_CLOEXEC);
        if (epoll_fd_ == -1) {
            perror("epoll_create1 failed");
            exit(EXIT_FAILURE);
        }
    }
    ~EpollManager() {
        close(epoll_fd_);
    }
    // 注册事件到 epoll（FD + 事件类型 + 用户数据）
    void add_event(int fd, uint32_t events, void* data) {
        struct epoll_event ev;
        ev.events = events;
        ev.data.ptr = data;  // 存储用户数据（如连接上下文）
        if (epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, fd, &ev) == -1) {
            perror("epoll_ctl add failed");
            close(fd);
        }
    }
    // 修改 epoll 中的事件
    void mod_event(int fd, uint32_t events, void* data) {
        struct epoll_event ev;
        ev.events = events;
        ev.data.ptr = data;
        if (epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, fd, &ev) == -1) {
            perror("epoll_ctl mod failed");
            close(fd);
        }
    }
    // 删除 epoll 中的事件并关闭 FD
    void del_event(int fd) {
        epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, fd, nullptr);
        close(fd);
    }
    // 事件循环：等待事件并分发到线程池
    void event_loop() {
        const int MAX_EVENTS = 1024;  // 每次最多处理 1024 个事件
        struct epoll_event events[MAX_EVENTS];
        while (true) {
            // 等待事件（-1：无限阻塞，直到有事件触发）
            int nfds = epoll_wait(epoll_fd_, events, MAX_EVENTS, -1);
            if (nfds == -1) {
                perror("epoll_wait failed");
                continue;
            }
            // 遍历事件，分发到线程池处理
            for (int i = 0; i < nfds; ++i) {
                auto handle_event = static_cast<std::function<void()>>(
                    events[i].data.ptr
                );
                thread_pool_->add_task(handle_event);
            }
        }
    }
private:
    int epoll_fd_;              // epoll 实例 FD
    ThreadPool* thread_pool_;   // 关联的线程池
};
#endif // EPOLL_MANAGER_H

3.3、模块 3：TCP 服务器（tcp_server.h）

处理 TCP 连接的全生命周期：监听端口、接收新连接、读 / 写数据、解决粘包问题（核心！）。

#ifndef TCP_SERVER_H
#define TCP_SERVER_H
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <functional>
#include <iostream>
#include "epoll_manager.h"
#include "thread_pool.h"
// 单个 TCP 连接的上下文（存储 FD、缓冲区、epoll 管理器）
struct ConnCtx {
    int fd;                     // 连接的 Socket FD
    EpollManager* epoll_mgr;    // 关联的 epoll 管理器
    char read_buf[4096];        // 读缓冲区（4K，适配多数场景）
    int read_len;               // 已读数据长度
    char write_buf[4096];       // 写缓冲区
    int write_len;              // 待写数据长度
};
class TcpServer {
public:
    // 构造：初始化 IP、端口、线程池
    TcpServer(const char* ip, int port, ThreadPool* thread_pool) 
        : thread_pool_(thread_pool), epoll_mgr_(thread_pool) {
        // 1. 创建监听 Socket（SOCK_CLOEXEC：子进程退出时关闭 FD）
        listen_fd_ = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
        if (listen_fd_ == -1) {
            perror("socket create failed");
            exit(EXIT_FAILURE);
        }
        // 2. 设置 Socket 选项（端口复用、非阻塞、缓冲区）
        set_socket_opt();
        // 3. 绑定 IP 和端口
        bind_addr(ip, port);
        // 4. 开始监听（backlog 与 somaxconn 一致，避免全连接队列溢出）
        if (listen(listen_fd_, 65536) == -1) {
            perror("listen failed");
            exit(EXIT_FAILURE);
        }
        std::cout << "服务器启动成功：" << ip << ":" << port << std::endl;
        // 5. 注册监听 FD 到 epoll（LT 模式，accept 无需读尽）
        auto accept_task = std::bind(&TcpServer::handle_accept, this);
        epoll_mgr_.add_event(listen_fd_, EPOLLIN, (void*)&accept_task);
    }
    // 启动服务器（进入 epoll 事件循环）
    void start() {
        epoll_mgr_.event_loop();
    }
private:
    // 设置 Socket 选项（端口复用、非阻塞、缓冲区）
    void set_socket_opt() {
        // 端口复用（避免服务重启时端口被 TIME_WAIT 占用）
        int reuse = 1;
        setsockopt(listen_fd_, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
        setsockopt(listen_fd_, SOL_SOCKET, SO_REUSEPORT, &reuse, sizeof(reuse));

        // 设置接收/发送缓冲区（与 tcp.rmem/tcp.wmem 对应）
        int buf_size = 16 * 1024 * 1024;  // 16M
        setsockopt(listen_fd_, SOL_SOCKET, SO_RCVBUF, &buf_size, sizeof(buf_size));
        setsockopt(listen_fd_, SOL_SOCKET, SO_SNDBUF, &buf_size, sizeof(buf_size));

        // 设置监听 FD 为非阻塞（避免 accept 阻塞）
        int flags = fcntl(listen_fd_, F_GETFL, 0);
        fcntl(listen_fd_, F_SETFL, flags | O_NONBLOCK);
    }
    // 绑定 IP 和端口
    void bind_addr(const char* ip, int port) {
        struct sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        // 绑定指定 IP（ nullptr 则绑定所有网卡）
        if (ip) {
            inet_pton(AF_INET, ip, &addr.sin_addr);
        } else {
            addr.sin_addr.s_addr = htonl(INADDR_ANY);
        }
        if (bind(listen_fd_, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
            perror("bind failed");
            exit(EXIT_FAILURE);
        }
    }
    // 处理新连接（accept）
    void handle_accept() {
        struct sockaddr_in client_addr;
        socklen_t client_len = sizeof(client_addr);
        // 接收新连接（SOCK_CLOEXEC：子进程退出时关闭 FD）
        int conn_fd = accept4(listen_fd_, (struct sockaddr*)&client_addr, 
                             &client_len, SOCK_CLOEXEC);
        if (conn_fd == -1) {
            perror("accept4 failed");
            return;
        }
        // 设置连接 FD 为非阻塞（配合 epoll ET 模式）
        int flags = fcntl(conn_fd, F_GETFL, 0);
        fcntl(conn_fd, F_SETFL, flags | O_NONBLOCK);

        // 创建连接上下文（存储 FD 和缓冲区）
        ConnCtx* ctx = new ConnCtx();
        ctx->fd = conn_fd;
        ctx->epoll_mgr = &epoll_mgr_;
        ctx->read_len = 0;
        ctx->write_len = 0;

        // 注册读事件到 epoll（ET 模式：EPOLLIN | EPOLLET）
        auto read_task = std::bind(&TcpServer::handle_read, this, ctx);
        epoll_mgr_.add_event(conn_fd, EPOLLIN | EPOLLET, (void*)&read_task);

        // 打印新连接信息
        std::cout << "新客户端连接：" << inet_ntoa(client_addr.sin_addr) 
                  << ":" << ntohs(client_addr.sin_port) << "（FD：" << conn_fd << "）" << std::endl;
    }
    // 处理读事件（ET 模式：必须一次性读尽数据，避免丢包）
    void handle_read(ConnCtx* ctx) {
        while (true) {
            // 读取客户端数据到缓冲区（避免缓冲区溢出）
            int n = read(ctx->fd, ctx->read_buf + ctx->read_len, 
                        sizeof(ctx->read_buf) – ctx->read_len);
            if (n > 0) {
                ctx->read_len += n;
                // 解决粘包问题：协议格式为「4字节长度（网络字节序） + 数据」
                while (ctx->read_len >= 4) {
                    // 解析数据长度（网络字节序→主机字节序）
                    int data_len = ntohl(*(int*)ctx->read_buf);
                    // 数据未接收完整，等待下一次读事件
                    if (ctx->read_len < 4 + data_len) {
                        break;
                    }
                    // 提取数据（此处简化为“回显”业务：将数据原样返回）
                    char* data = ctx->read_buf + 4;
                    std::cout << "收到客户端[" << ctx->fd << "]数据：" 
                              << std::string(data, data_len) << std::endl;
                    // 构造回显数据（遵循同样的协议格式）
                    *(int*)ctx->write_buf = htonl(data_len);
                    memcpy(ctx->write_buf + 4, data, data_len);
                    ctx->write_len = 4 + data_len;
                    // 注册写事件到 epoll（ET 模式）
                    auto write_task = std::bind(&TcpServer::handle_write, this, ctx);
                    ctx->epoll_mgr->mod_event(ctx->fd, EPOLLOUT | EPOLLET, (void*)&write_task);
                    // 移动剩余数据（处理粘包：如一次收到多个数据包）
                    int remain_len = ctx->read_len – (4 + data_len);
                    memmove(ctx->read_buf, ctx->read_buf + 4 + data_len, remain_len);
                    ctx->read_len = remain_len;
                }
            } else if (n == 0) {
                // 客户端主动关闭连接
                std::cout << "客户端[" << ctx->fd << "]关闭连接" << std::endl;
                ctx->epoll_mgr->del_event(ctx->fd);
                delete ctx;  // 释放连接上下文
                return;
            } else {
                // 非阻塞读：EAGAIN 表示暂时无数据，退出循环
                if (errno == EAGAIN || errno == EWOULDBLOCK) {
                    // 重新注册读事件（ET 模式下事件触发后需重新注册）
                    auto read_task = std::bind(&TcpServer::handle_read, this, ctx);
                    ctx->epoll_mgr->mod_event(ctx->fd, EPOLLIN | EPOLLET, (void*)&read_task);
                    break;
                } else {
                    // 其他错误（如连接异常），关闭连接
                    perror("read failed");
                    ctx->epoll_mgr->del_event(ctx->fd);
                    delete ctx;
                    return;
                }
            }
        }
    }
    // 处理写事件（ET 模式：必须一次性写尽数据）
    void handle_write(ConnCtx* ctx) {
        while (ctx->write_len > 0) {
            // 发送数据到客户端
            int n = write(ctx->fd, ctx->write_buf, ctx->write_len);
            if (n > 0) {
                // 移动待写数据（处理未写完的部分）
                memmove(ctx->write_buf, ctx->write_buf + n, ctx->write_len – n);
                ctx->write_len -= n;
            } else {
                // 非阻塞写：EAGAIN 表示发送缓冲区满，退出循环
                if (errno == EAGAIN || errno == EWOULDBLOCK) {
                    // 重新注册写事件
                    auto write_task = std::bind(&TcpServer::handle_write, this, ctx);
                    ctx->epoll_mgr->mod_event(ctx->fd, EPOLLOUT | EPOLLET, (void*)&write_task);
                    break;
                } else {
                    // 其他错误，关闭连接
                    perror("write failed");
                    ctx->epoll_mgr->del_event(ctx->fd);
                    delete ctx;
                    return;
                }
            }
        }
        // 数据写尽后，重新注册读事件，等待下一次客户端请求
        if (ctx->write_len == 0) {
            auto read_task = std::bind(&TcpServer::handle_read, this, ctx);
            ctx->epoll_mgr->mod_event(ctx->fd, EPOLLIN | EPOLLET, (void*)&read_task);
        }
    }
private:
    int listen_fd_;             // 监听 Socket FD
    ThreadPool* thread_pool_;   // 关联的线程池
    EpollManager epoll_mgr_;    // epoll 管理器
};
#endif // TCP_SERVER_H

3.4、模块 4：主函数与编译脚本

1）. 主函数（main.cpp）

整合所有模块，初始化线程池（核心数 = CPU 核心数），启动服务器：

#include "tcp_server.h"
#include "thread_pool.h"
#include <unistd.h>
int main(int argc, char* argv[]) {
    // 检查参数（./server  ip  port）
    if (argc != 3) {
        std::cerr << "用法：" << argv[0] << " <ip> <port>" << std::endl;
        std::cerr << "示例：" << argv[0] << " 0.0.0.0 8888" << std::endl;
        return 1;
    }
    const char* ip = argv[1];
    int port = atoi(argv[2]);

    // 初始化线程池（核心线程数=CPU核心数，避免线程切换开销）
    int core_threads = sysconf(_SC_NPROCESSORS_ONLN);
    ThreadPool thread_pool(core_threads);
    std::cout << "线程池初始化完成：" << core_threads << " 个核心线程" << std::endl;

    // 创建并启动 TCP 服务器
    TcpServer server(ip, port, &thread_pool);
    server.start();

    return 0;
}

2）. 编译脚本（Makefile）

CC = g++
# 编译选项：C++11、O2优化、警告提示
CFLAGS = -std=c++11 -O2 -Wall -Wextra
TARGET = high_concurrency_server
OBJS = main.o
all: $(TARGET)
# 链接生成可执行文件（需链接 pthread 库）
$(TARGET): $(OBJS)
$(CC) $(CFLAGS) -o $@ $^ -lpthread
# 编译 main.cpp
main.o: main.cpp tcp_server.h epoll_manager.h thread_pool.h
$(CC) $(CFLAGS) -c -o $@ $<
# 清理编译产物
clean:
rm -f $(TARGET) $(OBJS)

Part4进阶优化一：Slab 内存池

4.1、原有问题

基础版用 new/delete 频繁创建 / 销毁 ConnCtx（每个连接一个），小对象内存碎片率高达 20%-30%，长期运行会导致 “内存泄漏假象”（可用内存减少，但实际未泄漏）。

4.2、优化方案：Slab 内存池

Slab 是 Linux 内核经典小对象分配方案，核心思路：

• 按 ConnCtx 固定大小（约 8KB）划分 “Slab 页”，每个页切割成多个相同大小的对象块；
• 用空闲链表管理对象，分配时从链表取，释放时回收到链表，避免频繁向系统申请内存；
• 零碎片：固定大小对象无浪费，复用机制减少碎片。

4.3、代码实现（slab_pool.h）

#ifndef SLAB_POOL_H
#define SLAB_POOL_H
#include <vector>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include "tcp_server.h"
// 单个Slab页
struct SlabPage {
    char* data;
    size_t obj_size;
    size_t obj_count;
    std::vector<bool> used;
    SlabPage* next;
    SlabPage(size_t obj_size_, size_t page_size = 4096) {
        obj_size = obj_size_;
        obj_count = page_size / obj_size;
        if (obj_count == 0) obj_count = 1;
        // 4KB对齐分配内存
        int ret = posix_memalign((void**)&data, page_size, obj_count * obj_size);
        if (ret != 0) { perror("posix_memalign failed"); exit(EXIT_FAILURE); }
        used.resize(obj_count, false);
        next = nullptr;
    }
    ~SlabPage() { free(data); }
    void* alloc() {
        for (size_t i = 0; i < obj_count; ++i) {
            if (!used[i]) {
                used[i] = true;
                return data + i * obj_size;
            }
        }
        return nullptr;
    }
    bool free(void* ptr) {
        size_t offset = (char*)ptr – data;
        if (offset < 0 || offset >= obj_count * obj_size) return false;
        size_t idx = offset / obj_size;
        if (used[idx]) {
            used[idx] = false;
            memset(ptr, 0, obj_size); // 清零避免野指针
            return true;
        }
        return false;
    }
};
// 针对ConnCtx的Slab池
class SlabPool {
public:
    SlabPool() {
        // 8字节对齐计算ConnCtx大小
        obj_size = (sizeof(ConnCtx) + 7) & ~7;
        head_page = new SlabPage(obj_size);
        free_count = head_page->obj_count;
    }
    ~SlabPool() {
        SlabPage* curr = head_page;
        while (curr != nullptr) {
            SlabPage* next = curr->next;
            delete curr;
            curr = next;
        }
    }
    // 分配ConnCtx
    ConnCtx* alloc() {
        SlabPage* curr = head_page;
        while (curr != nullptr) {
            void* obj = curr->alloc();
            if (obj != nullptr) {
                free_count–;
                return static_cast<ConnCtx*>(obj);
            }
            curr = curr->next;
        }
        // 无空闲页，新建
        SlabPage* new_page = new SlabPage(obj_size);
        new_page->next = head_page;
        head_page = new_page;
        free_count += new_page->obj_count – 1;
        return static_cast<ConnCtx*>(new_page->alloc());
    }
    // 释放ConnCtx
    void free(ConnCtx* ctx) {
        if (ctx == nullptr) return;
        SlabPage* curr = head_page;
        while (curr != nullptr) {
            if (curr->free(ctx)) {
                free_count++;
                return;
            }
            curr = curr->next;
        }
        std::cerr << "SlabPool: 无效ConnCtx" << std::endl;
    }
    // 监控用：内存池使用率
    float get_usage() const {
        size_t total = 0;
        SlabPage* curr = head_page;
        while (curr != nullptr) { total += curr->obj_count; curr = curr->next; }
        return total == 0 ? 0.0f : (float)(total – free_count) / total;
    }
private:
    size_t obj_size;
    SlabPage* head_page;
    size_t free_count;
};
#endif // SLAB_POOL_H

4.4、集成到 TCP 服务器

修改 TcpServer，用 Slab 替换 new/delete：

// 1. 在TcpServer类中添加SlabPool成员
class TcpServer {
private:
    SlabPool conn_slab_pool;  // Slab内存池
    // … 其他成员
};
// 2. 处理新连接时：用Slab分配ConnCtx（替换new）
void TcpServer::handle_accept() {
    // … 原有代码
    // ConnCtx* ctx = new ConnCtx();  // 注释基础版代码
    ConnCtx* ctx = conn_slab_pool.alloc();  // Slab分配
    // … 其他代码
}
// 3. 连接关闭时：用Slab释放ConnCtx（替换delete）
void TcpServer::handle_read(ConnCtx* ctx) {
    if (n == 0) {
        // … 原有代码
        // delete ctx;  // 注释基础版代码
        conn_slab_pool.free(ctx);  // Slab释放
        return;
    }
    // … 其他错误处理处同理替换delete为conn_slab_pool.free(ctx)
}

4.5、优化效果

Part5进阶优化二：libco 协程

5.1、原有问题

线程池在 100 + 线程时，内核态上下文切换（context switch）次数激增（每秒数万次），CPU 开销占比超 30%，QPS 增长停滞。

5.2、优化方案：libco 协程

libco 是腾讯开源协程库，核心优势：

• 用户态切换：切换开销仅 10-20 纳秒（线程的 1/100）；
• 轻量级：单个协程栈最小 128KB，支持百万级协程；
• 无缝兼容：提供 IO 钩子（read/write/epoll_wait），无需修改原有 IO 逻辑。

5.3、环境准备：安装 libco

git clone https://github.com/Tencent/libco.git
cd libco
make -f Makefile.linux  # 生成libcolib.a
sudo cp co/*.h /usr/include/
sudo cp libcolib.a /usr/lib/

5.4、协程池实现（co_pool.h）

#ifndef CO_POOL_H
#define CO_POOL_H
#include <co_routine.h>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <thread>
// 协程任务
struct CoTask {
    std::function<void()> func;
    stCoRoutine_t* co;
    stCoRoutineAttr_t attr;
    CoTask* next;
    CoTask() {
        attr.stack_size = 128 * 1024;  // 协程栈128KB
        attr.share_stack = nullptr;
        co = nullptr;
        next = nullptr;
    }
};
// 协程池
class CoPool {
public:
    CoPool(size_t co_count = 1024) : stop_(false) {
        // 预创建协程
        for (size_t i = 0; i < co_count; ++i) {
            free_co_list_.push_back(new CoTask());
        }
        // 调度线程：分发任务
        schedule_thread_ = std::thread(&CoPool::schedule, this);
    }
    ~CoPool() {
        stop_ = true;
        cond_.notify_one();
        schedule_thread_.join();
        // 释放资源
        while (!task_queue_.empty()) { delete task_queue_.front(); task_queue_.pop(); }
        for (auto task : free_co_list_) delete task;
    }
    void add_task(std::function<void()> func) {
        std::unique_lock<std::mutex> lock(mtx_);
        CoTask* task = nullptr;
        // 复用空闲协程
        if (!free_co_list_.empty()) {
            task = free_co_list_.back();
            free_co_list_.pop_back();
        } else {
            task = new CoTask();
        }
        task->func = func;
        task_queue_.push(task);
        cond_.notify_one();
    }
private:
    // 协程入口函数（libco要求静态）
    static void co_entry(void* arg) {
        CoTask* task = static_cast<CoTask*>(arg);
        if (task->func) task->func();
        // 任务完成，回收到空闲列表
        CoPool* pool = static_cast<CoPool*>(task->attr.user_data);
        std::unique_lock<std::mutex> lock(pool->mtx_);
        pool->free_co_list_.push_back(task);
    }
    // 调度线程逻辑
    void schedule() {
        while (!stop_) {
            std::unique_lock<std::mutex> lock(mtx_);
            cond_.wait(lock, [this]() { return stop_ || !task_queue_.empty(); });
            if (stop_) break;
            CoTask* task = task_queue_.front();
            task_queue_.pop();
            lock.unlock();
            // 初始化或重置协程
            if (task->co == nullptr) {
                task->attr.user_data = this;
                co_create(&task->co, &task->attr, co_entry, task);
            } else {
                co_reset(task->co, co_entry, task);
            }
            // 启动协程
            co_resume(task->co);
        }
    }
private:
    bool stop_;
    std::thread schedule_thread_;
    std::queue<CoTask*> task_queue_;
    std::vector<CoTask*> free_co_list_;
    std::mutex mtx_;
    std::condition_variable cond_;
};
#endif // CO_POOL_H

5.5、集成到服务器：替换线程池

1）. 修改主函数（main.cpp）

#include "co_pool.h"  // 替换#include "thread_pool.h"
int main(int argc, char* argv[]) {
    // … 其他代码
    // ThreadPool thread_pool(core_threads);  // 注释线程池
    CoPool co_pool(1024);  // 初始化协程池（1024个预创建协程）
    TcpServer server(ip, port, &co_pool);  // 传递协程池
    // …
}

2）. 修改 EpollManager

// 1. 替换ThreadPool为CoPool
class EpollManager {
public:
    EpollManager(CoPool* co_pool) : co_pool_(co_pool) {  // 原参数是ThreadPool*
        epoll_fd_ = epoll_create1(EPOLL_CLOEXEC);
        if (epoll_fd_ == -1) { perror("epoll_create1 failed"); exit(EXIT_FAILURE); }
    }
    // … 其他代码
private:
    CoPool* co_pool_;  // 原成员是ThreadPool*
    int epoll_fd_;
};
// 2. 事件分发时调用协程池
void EpollManager::event_loop() {
    // … 原有代码
    for (int i = 0; i < nfds; ++i) {
        auto handle_event = static_cast<std::function<void()>>(events[i].data.ptr);
        co_pool_->add_task(handle_event);  // 原是thread_pool_->add_task
    }
}

3）. 修改 TcpServer 构造函数

class TcpServer {
public:
    // 原参数是ThreadPool*，改为CoPool*
    TcpServer(const char* ip, int port, CoPool* co_pool) 
        : co_pool_(co_pool), epoll_mgr_(co_pool) {  // 传递协程池给EpollManager
        // … 原有代码
    }
private:
    CoPool* co_pool_;  // 原成员是ThreadPool*
    // … 其他代码
};

5.6、优化效果

Part6进阶优化三：LVS 四层负载均衡

6.1、原有问题

单节点服务器受限于 FD（约 100 万）、CPU、带宽，并发上限约 80-90 万，无法满足超大规模场景（如电商秒杀 200 万 + 并发）。

6.2、优化方案：LVS 集群

LVS（Linux Virtual Server）是四层负载均衡技术，核心优势：

• 高性能：仅转发数据包，不处理应用层逻辑，转发效率接近硬件（每秒百万级数据包）；
• 高可用：支持多节点集群，单节点故障不影响整体服务；
• 线性扩展：新增节点即可提升并发能力。

集群架构：

• Director（调度器）：对外提供 VIP（虚拟 IP），接收客户端请求，转发到后端 Real Server；
• Real Server：运行优化后的并发服务器，处理实际业务；
• 后端网络：Director 与 Real Server 通过内网通信（如 192.168.0.0/24）。

6.3、实战配置（1 Director + 3 Real Server）

环境准备（4 台服务器）

1. Director 节点配置

（1）安装 ipvsadm（LVS 管理工具）

sudo apt install ipvsadm

（2）开启内核转发

# 临时开启
sudo echo 1 > /proc/sys/net/ipv4/ip_forward
# 永久开启
sudo echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.conf
sudo sysctl -p

（3）配置 LVS 虚拟服务

# 清除原有配置
sudo ipvsadm -C
# 添加虚拟服务：VIP=10.0.0.100，端口=8888，调度算法=加权轮询（WRR）
sudo ipvsadm -A -t 10.0.0.100:8888 -s wrr
# 添加后端Real Server（-g：DR模式，-w：权重）
sudo ipvsadm -a -t 10.0.0.100:8888 -r 192.168.0.2:8888 -g -w 3
sudo ipvsadm -a -t 10.0.0.100:8888 -r 192.168.0.3:8888 -g -w 2
sudo ipvsadm -a -t 10.0.0.100:8888 -r 192.168.0.4:8888 -g -w 2
# 保存配置
sudo ipvsadm -S > /etc/sysconfig/ipvsadm

（4）验证配置

sudo ipvsadm -Ln

输出如下表示配置成功：

IP Virtual Server version 1.2.1 (size=4096)
Prot LocalAddress:Port Scheduler Flags
  -> RemoteAddress:Port           Forward Weight ActiveConn InActConn
TCP  10.0.0.100:8888 wrr
  -> 192.168.0.2:8888             Route   3      0          0
  -> 192.168.0.3:8888             Route   2      0          0
  -> 192.168.0.4:8888             Route   2      0          0

2. Real Server 节点配置（3 台均需执行）

（1）绑定 VIP 到回环网卡（避免 ARP 冲突）

# 临时绑定
sudo ifconfig lo:0 10.0.0.100 netmask 255.255.255.255 up
# 永久绑定（开机执行）
sudo echo "ifconfig lo:0 10.0.0.100 netmask 255.255.255.255 up" >> /etc/rc.local

（2）关闭 ARP 响应（避免客户端直接连接 Real Server）

# 临时关闭
sudo echo 1 > /proc/sys/net/ipv4/conf/all/arp_ignore
sudo echo 2 > /proc/sys/net/ipv4/conf/all/arp_announce
# 永久关闭
sudo echo "net.ipv4.conf.all.arp_ignore = 1" >> /etc/sysctl.conf
sudo echo "net.ipv4.conf.all.arp_announce = 2" >> /etc/sysctl.conf
sudo sysctl -p

（3）启动优化后的服务器

# 每台Real Server启动服务器（绑定内网IP）
./high_concurrency_server 192.168.0.2 8888  # Real Server 1
./high_concurrency_server 192.168.0.3 8888  # Real Server 2
./high_concurrency_server 192.168.0.4 8888  # Real Server 3

6.4、优化效果

Part7进阶优化四：Prometheus+Grafana

7.1、原有问题

基础版服务器缺乏监控，无法实时感知 FD 使用率、QPS 突降、延迟飙升等问题，故障发生后只能 “事后救火”。

7.2、优化方案：Prometheus+Grafana

• Prometheus：时序数据库，采集服务器指标（QPS、FD 使用率），支持 PromQL 查询；
• Node Exporter：采集系统指标（CPU、内存、带宽）；
• Grafana：可视化仪表盘，设置告警（邮件 / 钉钉），提前规避故障。

7.3、实战部署

环境准备（2 台服务器）

1. 部署 Node Exporter（所有 Real Server）

采集系统指标：

# 下载Node Exporter
wget https://github.com/prometheus/node_exporter/releases/download/v1.6.1/node_exporter-1.6.1.linux-amd64.tar.gz
tar -zxvf node_exporter-1.6.1.linux-amd64.tar.gz
# 启动（端口9100）
cd node_exporter-1.6.1.linux-amd64
nohup ./node_exporter –web.listen-address=":9100" &

2. 服务器集成 Prometheus 客户端（暴露业务指标）

（1）安装 prometheus-cpp

git clone https://github.com/jupp0r/prometheus-cpp.git
cd prometheus-cpp && mkdir build && cd build
cmake .. -DBUILD_SHARED_LIBS=ON
make -j4 && sudo make install

（2）添加监控指标（metrics.h）

#ifndef METRICS_H
#define METRICS_H
#include <prometheus/counter.h>
#include <prometheus/gauge.h>
#include <prometheus/histogram.h>
#include <prometheus/registry.h>
#include <prometheus/exposer.h>
#include "slab_pool.h"
class ServerMetrics {
public:
    ServerMetrics(const std::string& addr = ":9101") {
        // 初始化注册表
        registry_ = std::make_shared<prometheus::Registry>();
        // 定义指标（QPS、延迟、FD使用率、内存池使用率）
        init_metrics();
        // 暴露metrics接口（端口9101）
        exposer_ = std::make_unique<prometheus::Exposer>(addr);
        exposer_->RegisterCollectable(registry_);
    }
    // 更新请求指标（QPS、延迟）
    void update_request(bool success, double latency_ms) {
        request_total_.Increment();
        success ? request_success_.Increment() : request_fail_.Increment();
        request_latency_.Observe(latency_ms);
    }
    // 更新资源指标（FD、内存池）
    void update_resource(int fd_used, int fd_total, SlabPool& slab) {
        fd_usage_.Set((double)fd_used / fd_total);
        slab_usage_.Set(slab.get_usage());
    }
private:
    void init_metrics() {
        // 总请求数
        auto& req_total = prometheus::BuildCounter()
            .Name("server_request_total")
            .Help("Total requests")
            .Register(*registry_);
        request_total_ = &req_total.Add({{"service", "concurrency_server"}});
        // 成功/失败请求数
        auto& req_success = prometheus::BuildCounter()
            .Name("server_request_success")
            .Help("Successful requests")
            .Register(*registry_);
        request_success_ = &req_success.Add({{"service", "concurrency_server"}});
        auto& req_fail = prometheus::BuildCounter()
            .Name("server_request_fail")
            .Help("Failed requests")
            .Register(*registry_);
        request_fail_ = &req_fail.Add({{"service", "concurrency_server"}});
        // 请求延迟（直方图：0.1ms~500ms）
        auto& req_latency = prometheus::BuildHistogram()
            .Name("server_request_latency_ms")
            .Help("Request latency")
            .Buckets({0.1, 0.5, 1, 5, 10, 50, 100, 500})
            .Register(*registry_);
        request_latency_ = &req_latency.Add({{"service", "concurrency_server"}});
        // FD使用率
        auto& fd_usage = prometheus::BuildGauge()
            .Name("server_fd_usage")
            .Help("FD usage ratio (0-1)")
            .Register(*registry_);
        fd_usage_ = &fd_usage.Add({{"service", "concurrency_server"}});
        // 内存池使用率
        auto& slab_usage = prometheus::BuildGauge()
            .Name("server_slab_usage")
            .Help("Slab pool usage ratio (0-1)")
            .Register(*registry_);
        slab_usage_ = &slab_usage.Add({{"service", "concurrency_server"}});
    }
private:
    std::shared_ptr<prometheus::Registry> registry_;
    std::unique_ptr<prometheus::Exposer> exposer_;
    // 指标对象
    prometheus::Counter* request_total_;
    prometheus::Counter* request_success_;
    prometheus::Counter* request_fail_;
    prometheus::Histogram* request_latency_;
    prometheus::Gauge* fd_usage_;
    prometheus::Gauge* slab_usage_;
};
#endif // METRICS_H

（3）集成到 TcpServer

// 1. 添加ServerMetrics成员
class TcpServer {
private:
    ServerMetrics metrics_;  // 监控对象
    // … 其他成员
};
// 2. 处理请求时更新指标（handle_read中）
#include <chrono>
void TcpServer::handle_read(ConnCtx* ctx) {
    // … 读取数据后
    auto start = std::chrono::high_resolution_clock::now();
    // 处理业务（如回显）
    bool success = true;
    auto end = std::chrono::high_resolution_clock::now();
    double latency_ms = std::chrono::duration<double, std::milli>(end – start).count();
    // 更新请求指标
    metrics_.update_request(success, latency_ms);
    // … 其他代码
}
// 3. 定时更新资源指标（添加定时协程）
void TcpServer::start_metrics_timer() {
    co_pool_->add_task([this]() {
        while (true) {
            // 获取FD使用数（实际需通过系统调用获取，此处简化）
            int fd_used = system("ls /proc/$$/fd | wc -l");
            int fd_total = 1000000;
            // 更新资源指标
            metrics_.update_resource(fd_used, fd_total, conn_slab_pool);
            sleep(10);  // 每10秒更新一次
        }
    });
}
// 4. 在TcpServer构造函数中启动定时任务
TcpServer::TcpServer(const char* ip, int port, CoPool* co_pool) 
    : co_pool_(co_pool), epoll_mgr_(co_pool), metrics_(":9101") {
    // … 原有代码
    start_metrics_timer();  // 启动监控定时任务
}

3. 部署 Prometheus（192.168.0.10）

（1）下载并启动

wget https://github.com/prometheus/prometheus/releases/download/v2.45.0/prometheus-2.45.0.linux-amd64.tar.gz
tar -zxvf prometheus-2.45.0.linux-amd64.tar.gz
cd prometheus-2.45.0.linux-amd64

（2）配置 prometheus.yml

global:
  scrape_interval: 10s  # 采集间隔
scrape_configs:
  # 采集系统指标（Node Exporter）
  – job_name: 'node'
    static_configs:
      – targets: ['192.168.0.2:9100', '192.168.0.3:9100', '192.168.0.4:9100']
  # 采集业务指标（服务器）
  – job_name: 'server'
    static_configs:
      – targets: ['192.168.0.2:9101', '192.168.0.3:9101', '192.168.0.4:9101']

（3）启动 Prometheus

nohup ./prometheus –config.file=prometheus.yml –web.listen-address=":9090" &

访问 http://192.168.0.10:9090，在 “Targets” 页面确认采集目标状态为 “UP”。

4. 部署 Grafana（192.168.0.11）

（1）安装并启动

sudo apt install grafana -y
sudo systemctl start grafana-server
sudo systemctl enable grafana-server

（2）配置 Prometheus 数据源

• 访问 http://192.168.0.11:3000，默认账号密码 admin/admin；
• 左侧 “Data Sources”→“Add data source”→选择 “Prometheus”；
• 填写 “URL”：http://192.168.0.10:9090，点击 “Save & Test”。

（3）创建仪表盘

1. 左侧 “Dashboards”→“New dashboard”→“Add visualization”；

2. 用 PromQL 查询指标，例如：

• QPS：rate(server_request_total[5m])
• FD 使用率：server_fd_usage
• 平均延迟：avg(rate(server_request_latency_ms_sum[5m]) / rate(server_request_latency_ms_count[5m]))

• 保存仪表盘，设置刷新间隔（如 10 秒）。

（4）设置告警（以 FD 使用率为例）

• 编辑 FD 使用率图表→“Alert”→“Create Alert”；
• 条件：server_fd_usage > 0.8（使用率超 80%），持续 “1m”；
• 配置告警渠道（如邮件），填写接收地址；
• 保存后，当指标触发阈值时自动发送告警。

7.4、优化效果

• 实时感知：通过 Grafana 直观查看 QPS、延迟、FD 使用率，掌握服务器状态；
• 故障预警：FD 使用率超 80%、QPS 突降 50% 时，5 分钟内收到告警，提前扩容；
• 问题定位：通过 PromQL 查询历史数据，快速定位 “延迟飙升” 是 CPU 满负荷还是内存碎片导致。

Part8优化后整体架构与性能对比

8.1、整体架构（数据流向）

1）.客户端 → 向 LVS 的 VIP（10.0.0.100:8888）发起请求；

2）.LVS Director→ 按加权轮询转发请求到 Real Server（192.168.0.2~0.4）；

3）.Real Server →

• epoll 监听 IO 事件；
• libco 协程处理业务逻辑；
• Slab 内存池管理 ConnCtx；
• ServerMetrics 暴露业务指标（9101 端口）；
• Node Exporter 暴露系统指标（9100 端口）；

4）.监控层 →

• Prometheus（192.168.0.10）采集指标；
• Grafana（192.168.0.11）可视化 + 告警。

8.2、核心指标对比

Part9生产落地建议

• 逐步迭代：先上线 Slab 内存池和协程优化，验证稳定性后再搭建 LVS 和监控；
• 灰度发布：LVS 集群上线时，先切 10% 流量到新架构，无问题再扩大比例；
• 压力测试：上线前用wrk模拟 2 倍峰值并发，验证抗压力能力；
• 文档沉淀：记录 Slab 配置、LVS 部署步骤、告警规则，方便后续维护。

总结

本文从基础版 “epoll + 线程池” 服务器出发，针对生产环境四大痛点，通过 Slab 内存池、libco 协程、LVS 集群、Prometheus 监控 四大优化，打造了生产级百万并发服务器。核心逻辑是：

• 内存复用：Slab 解决小对象碎片，让服务器长期稳定运行；
• 轻量并发：协程降低切换开销，让 CPU 更多用于业务处理；
• 集群扩展：LVS 突破单节点瓶颈，实现高可用与线性扩展；
• 可观测性：监控让故障从 “事后救火” 变为 “提前预警”。

这套优化方案不仅适用于 C++ 服务器，其核心思想（内存管理、轻量并发、集群扩展、可观测性）也可迁移到 Java、Go 等其他语言的高并发系统中，是生产级架构设计的通用思路。

点击下方关注公众号【Linux教程】，获取 大厂技术栈学习路线、项目教程、简历模板、大厂面试题pdf文档、大厂面经、编程交流圈子等等。