Cplusplus-Concurrency-In-Practice：现代 C++ 并发编程实践指南

icy 今天 2 抢沙发

默认

摘要： Cplusplus-Concurrency-In-Practice：现代 C++ 并发编程实践指南项目概述 Cplusplus-Concurrency-In-Practice 是...

Cplusplus-Concurrency-In-Practice：现代 C++ 并发编程实践指南

项目概述

Cplusplus-Concurrency-In-Practice 是一个专注于现代 C++ 并发编程的开源学习项目，由开发者 forhappy 创建并维护。该项目旨在为 C++ 开发者提供一套全面、实用的并发编程学习资源和实践示例，涵盖了从基础概念到高级技术的完整知识体系。

项目地址：https://github.com/forhappy/Cplusplus-Concurrency-In-Practice

核心特性

1. 全面的知识覆盖

该项目系统性地整理了 C++11/14/17/20 标准中引入的并发编程特性，包括： - 线程管理（std::thread） - 互斥锁与同步机制（std::mutex, std::lock_guard, std::unique_lock） - 条件变量（std::condition_variable） - 原子操作（std::atomic） - 异步编程（std::async, std::future, std::promise） - 内存模型与内存顺序

2. 实践导向的代码示例

项目提供了大量可直接运行的代码示例，每个示例都配有详细的注释说明，帮助开发者理解并发编程的实际应用场景。

3. 常见并发模式实现

包含了生产者-消费者模式、读写锁模式、线程池等常见并发设计模式的实现。

实用示例

示例 1：基础线程创建与管理

text

#include <iostream>
#include <thread>
#include <vector>

void worker(int id) {
    std::cout << "Thread " << id << " is working..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Thread " << id << " finished." << std::endl;
}

int main() {
    std::vector<std::thread> threads;
    
    // 创建多个线程
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(worker, i);
    }
    
    // 等待所有线程完成
    for (auto& t : threads) {
        t.join();
    }
    
    std::cout << "All threads completed." << std::endl;
    return 0;
}

示例 2：使用互斥锁保护共享数据

text

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>

std::mutex mtx;
int shared_counter = 0;

void increment_counter(int id) {
    for (int i = 0; i < 1000; ++i) {
        // 使用 lock_guard 自动管理锁
        std::lock_guard<std::mutex> lock(mtx);
        ++shared_counter;
    }
    std::cout << "Thread " << id << " finished." << std::endl;
}

int main() {
    std::vector<std::thread> threads;
    
    // 创建 10 个线程同时增加计数器
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment_counter, i);
    }
    
    for (auto& t : threads) {
        t.join();
    }
    
    std::cout << "Final counter value: " << shared_counter << std::endl;
    return 0;
}

示例 3：生产者-消费者模式实现

text

#include <iostream>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <chrono>

template<typename T>
class ThreadSafeQueue {
private:
    std::queue<T> queue_;
    mutable std::mutex mutex_;
    std::condition_variable cond_;
    
public:
    void push(T value) {
        std::lock_guard<std::mutex> lock(mutex_);
        queue_.push(std::move(value));
        cond_.notify_one();
    }
    
    bool try_pop(T& value) {
        std::lock_guard<std::mutex> lock(mutex_);
        if (queue_.empty()) {
            return false;
        }
        value = std::move(queue_.front());
        queue_.pop();
        return true;
    }
    
    void wait_and_pop(T& value) {
        std::unique_lock<std::mutex> lock(mutex_);
        cond_.wait(lock, [this] { return !queue_.empty(); });
        value = std::move(queue_.front());
        queue_.pop();
    }
    
    bool empty() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return queue_.empty();
    }
};

void producer(ThreadSafeQueue<int>& queue, int id) {
    for (int i = 0; i < 5; ++i) {
        int value = id * 100 + i;
        queue.push(value);
        std::cout << "Producer " << id << " produced: " << value << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

void consumer(ThreadSafeQueue<int>& queue, int id) {
    for (int i = 0; i < 3; ++i) {
        int value;
        queue.wait_and_pop(value);
        std::cout << "Consumer " << id << " consumed: " << value << std::endl;
    }
}

int main() {
    ThreadSafeQueue<int> queue;
    
    // 创建生产者和消费者线程
    std::vector<std::thread> producers;
    std::vector<std::thread> consumers;
    
    for (int i = 0; i < 2; ++i) {
        producers.emplace_back(producer, std::ref(queue), i);
    }
    
    for (int i = 0; i < 3; ++i) {
        consumers.emplace_back(consumer, std::ref(queue), i);
    }
    
    // 等待所有线程完成
    for (auto& t : producers) {
        t.join();
    }
    
    for (auto& t : consumers) {
        t.join();
    }
    
    return 0;
}

项目结构

Cplusplus-Concurrency-In-Practice 项目通常包含以下目录结构：

text

├── basics/          # 基础并发概念
├── synchronization/ # 同步机制
├── atomic/         # 原子操作
├── async/          # 异步编程
├── patterns/       # 并发模式
├── memory_model/   # 内存模型
└── examples/       # 综合示例