C++多线程高并发：从原理到实战

最新推荐文章于 2025-07-17 11:25:31 发布

原创最新推荐文章于 2025-07-17 11:25:31 发布 · 1k 阅读

CC 4.0 BY-SA版权

文章标签：

在互联网服务、实时计算、游戏服务器等场景中，高并发处理能力是衡量系统性能的核心指标。C++凭借其高性能和对底层资源的精细控制能力，成为构建高并发系统的热门选择。本文将深入探讨如何利用C++11及以上版本的多线程特性，结合经典设计模式，实现高效并发编程。

为什么选择C++处理高并发？

性能优势：C++直接操作内存，无GC停顿，适合低延迟场景（如游戏服务器）。
资源可控性：手动管理线程生命周期，避免语言层面的资源开销（如Java线程栈占用）。

现代C++支持：C++11引入的<thread>、<mutex>、<atomic>等库简化了并发编程。

// 基础线程创建
void task(int id) {
    std::cout << "Thread " << id << " is running\n";
}

int main() {
    std::thread t1(task, 1);
    std::thread t2(task, 2);
    t1.join();
    t2.join();
    return 0;
}

多线程基础：从`std::thread`到线程池

1. 线程管理

RAII管理：使用std::unique_ptr封装线程对象，避免因异常导致线程泄漏。

线程组控制：通过std::vector<std::thread>批量管理线程。

代码示例：线程池实现

class ThreadPool {
public:
    ThreadPool(size_t num_threads) {
        for (size_t i = 0; i < num_threads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        this->condition.wait(lock, [this] { 
                            return this->stop || !this->tasks.empty(); 
                        });
                        if (this->stop && this->tasks.empty()) return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for (auto& worker : workers) worker.join();
    }

    template<class F>
    void enqueue(F&& f) {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            tasks.emplace(std::forward<F>(f));
        }
        condition.notify_one();
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop = false;
};

并发的三大核心问题

1. 竞态条件（Race Condition）

问题：多个线程同时修改共享数据导致结果不可预测。

解决方案：使用互斥锁（std::mutex）或读写锁（std::shared_mutex）。

2. 死锁（Deadlock）

经典场景：线程A持有锁1等待锁2，线程B持有锁2等待锁1。

预防方法：
按固定顺序获取锁（如全局锁排序）。
使用std::lock()一次性获取多个锁。

3. 数据竞争（Data Race）

检测工具：Clang的ThreadSanitizer（TSAN）。
修复方案：使用原子操作（std::atomic<T>）替代非原子变量。

无锁编程与原子操作

1. CAS（Compare-And-Swap）原理

std::atomic<int> counter(0);
counter.fetch_add(1, std::memory_order_relaxed); // 原子自增

2. 无锁队列实现

template<typename T>
class LockFreeQueue {
    struct Node {
        T data;
        std::atomic<Node*> next;
        Node(T val) : data(val), next(nullptr) {}
    };

    std::atomic<Node*> head;
    std::atomic<Node*> tail;

public:
    void push(T val) {
        Node* new_node = new Node(val);
        Node* old_tail = tail.load();
        while (!old_tail->next.compare_exchange_weak(nullptr, new_node)) {
            old_tail = tail.load();
        }
        tail.compare_exchange_weak(old_tail, new_node);
    }
};

高并发网络请求处理示例

场景：实现一个支持10万QPS的HTTP请求处理器

Epoll + 非阻塞IO：利用Linux的epoll实现事件驱动模型。
线程池分发任务：将IO事件分发给线程池处理。
内存池优化：预分配内存减少动态分配开销。

代码示例

void handle_request(int client_fd) {
    // 读取请求并处理
    std::string response = process_request(client_fd);
    send(client_fd, response.c_str(), response.size(), 0);
}

int main() {
    ThreadPool pool(8); // 8个工作线程
    int epoll_fd = epoll_create1(0);
    // ... 初始化epoll监听端口 ...
    while (true) {
        int n = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        for (int i = 0; i < n; ++i) {
            pool.enqueue([events[i].data.fd] { 
                handle_request(events[i].data.fd); 
            });
        }
    }
}