并发基础与线程生命周期管理

自 C++11 起，标准库通过 <thread> 提供了跨平台的原生多线程能力。开发者可以通过实例化 std::thread 来启动新的执行流，其构造函数接收任意可调用实体（如普通函数、仿函数或 Lambda 表达式）作为执行主体。

#include <iostream>
#include <thread>
#include <string>

void print_message(const std::string& msg, int repeat_count) {
    for (int i = 0; i < repeat_count; ++i) {
        std::cout << msg << "\n";
    }
}

int main() {
    std::thread worker(print_message, "Executing concurrent task", 3);
    
    // 必须明确线程的归宿：阻塞等待或分离
    if (worker.joinable()) {
        worker.join(); 
    }
    return 0;
}

在 std::thread 对象的生命周期结束前，必须显式调用 join() 阻塞等待其完成，或者调用 detach() 将其转为后台守护线程。若未做处理，析构函数将直接调用 std::terminate 终止整个程序。

共享资源保护与同步原语

互斥量与 RAII 锁管理

为了防止多个线程同时修改同一内存区域导致的数据竞争，标准库提供了 std::mutex。在实际工程中，强烈建议避免手动调用 lock() 和 unlock()，而是利用 RAII 机制的包装类来确保异常安全。

#include <mutex>
#include <vector>

std::mutex data_mutex;
std::vector<int> shared_buffer;

void append_data(int value) {
    // std::lock_guard 在构造时加锁，析构时自动解锁
    std::lock_guard<std::mutex> guard(data_mutex);
    shared_buffer.push_back(value);
}

当需要更复杂的锁控制（如超时尝试、手动解锁或配合条件变量）时，应使用 std::unique_lock，它提供了比 lock_guard 更丰富的接口。

条件变量与线程间通信

std::condition_variable 允许线程在特定条件未满足时进入休眠状态，从而避免忙等待（Busy Waiting）。它必须与 std::unique_lock 结合使用。

#include <condition_variable>

std::condition_variable state_cv;
std::mutex state_mutex;
bool is_data_prepared = false;

void consumer_thread() {
    std::unique_lock<std::mutex> lk(state_mutex);
    // 阻塞等待，直到谓词返回 true，同时自动处理虚假唤醒
    state_cv.wait(lk, [] { return is_data_prepared; });
    // 处理准备好的数据
}

void producer_thread() {
    {
        std::lock_guard<std::mutex> lk(state_mutex);
        is_data_prepared = true;
    }
    state_cv.notify_all(); // 唤醒所有等待该条件的线程
}

异步任务与结果获取

对于不需要精细控制线程生命周期的场景，std::async 是更优的选择。它会自动管理底层线程，并返回一个 std::future 对象用于异步获取执行结果。

#include <future>
#include <numeric>
#include <vector>

long long calculate_sum(const std::vector<int>& nums) {
    return std::accumulate(nums.begin(), nums.end(), 0LL);
}

int main() {
    std::vector<int> numbers(1000000, 1);
    // std::launch::async 强制异步执行
    std::future<long long> sum_future = std::async(std::launch::async, calculate_sum, numbers);
    
    // 执行其他逻辑...
    
    long long total = sum_future.get(); // 阻塞获取结果
    return 0;
}

若需要在线程间单向传递数据或异常，可以使用 std::promise 设置值，并通过其关联的 std::future 读取。

std::promise<std::string> result_promise;
std::future<std::string> result_future = result_promise.get_future();

void async_operation(std::promise<std::string> prom) {
    try {
        // 模拟耗时操作
        prom.set_value("Operation_Success");
    } catch (...) {
        prom.set_exception(std::current_exception());
    }
}

int main() {
    std::thread t(async_operation, std::move(result_promise));
    std::cout << result_future.get() << "\n";
    t.join();
}

线程独立状态与无锁编程

线程局部存储 (TLS)

通过 thread_local 修饰符声明的变量，每个线程都会拥有自己独立的实例，互不干扰。这非常适合用于存储线程特定的上下文信息或缓存。

thread_local unsigned int thread_specific_seed = 0;

void initialize_random_seed() {
    thread_specific_seed = static_cast<unsigned int>(std::hash<std::thread::id>{}(std::this_thread::get_id()));
}

原子操作

针对基础数据类型的并发读写，std::atomic 提供了硬件级别的无锁同步方案，其性能通常优于互斥锁。

#include <atomic>

std::atomic<size_t> active_connections{0};

void on_client_connect() {
    active_connections.fetch_add(1, std::memory_order_relaxed);
}

void on_client_disconnect() {
    active_connections.fetch_sub(1, std::memory_order_relaxed);
}

自定义线程池架构设计

标准库并未内置线程池组件，但我们可以利用现有原语构建。一个健壮的线程池通常包含任务队列、工作线程组以及同步控制逻辑。

#include <queue>
#include <functional>
#include <condition_variable>

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

    void submit(std::function<void()> job) {
        {
            std::lock_guard<std::mutex> lock(queue_mutex);
            task_queue.push(std::move(job));
        }
        condition.notify_one();
    }

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

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> task_queue;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop_flag;
};

并发编程最佳实践

• 控制线程数量：频繁创建和销毁线程会带来显著的系统开销，应尽量复用线程（如使用线程池）。
• 优先高层抽象：在不需要精细控制时，优先使用 std::async 和并行算法，让运行时库决定最优的调度策略。
• 避免死锁：当需要同时锁定多个互斥量时，务必使用 std::lock 或 std::scoped_lock (C++17) 来保证加锁顺序的一致性。
• 内存序控制：在使用 std::atomic 时，深入理解 memory_order，在确保正确性的前提下选择最宽松的内存序以提升性能。
• 工具辅助：常态化使用 ThreadSanitizer (TSan) 或 Helgrind 等工具进行数据竞争和死锁检测。