11、探索现代C++中的并发编程与异步编程

最新推荐文章于 2025-10-13 05:18:41 发布

最新推荐文章于 2025-10-13 05:18:41 发布

阅读量104

点赞数 2

CC 4.0 BY-SA版权

分类专栏：探索C++17的清洁代码之道文章标签： C++ 并发编程异步编程

本文链接：https://blog.youkuaiyun.com/view3/article/details/148743442

探索C++17的清洁代码之道专栏收录该内容

12 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

探索现代C++中的并发编程与异步编程

1. 并发编程基础

并发编程是指程序在同一时间段内处理多个任务的能力。在多核处理器时代，充分利用硬件资源，提高程序性能，是每个开发者都需要掌握的重要技能之一。C++11引入了对并发编程的支持，使开发者能够更方便地编写高效且可靠的并发程序。

1.1 线程管理

线程是操作系统能够进行运算调度的最小单位。C++11引入了 <thread> 库，提供了创建和管理线程的功能。下面是一个简单的例子，展示了如何创建和启动线程：

#include <iostream>
#include <thread>

void print_thread_id(int id) {
    std::cout << "Thread ID: " << id << std::endl;
}

int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);

    t1.join();
    t2.join();

    return 0;
}

1.2 线程同步

多线程编程中，线程同步是一个至关重要的问题。如果不加以控制，多个线程可能会同时访问共享资源，导致数据竞争。C++11提供了多种同步机制，如互斥锁（mutex）、条件变量（condition_variable）等。下面的例子展示了如何使用互斥锁保护共享资源：

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

std::mutex mtx;

void print_block(int n, char c) {
    std::lock_guard<std::mutex> lock(mtx);
    for (int i = 0; i < n; ++i) {
        std::cout << c;
    }
    std::cout << '\n';
}

int main() {
    std::thread th1(print_block, 50, '*');
    std::thread th2(print_block, 50, '$');

    th1.join();
    th2.join();

    return 0;
}

2. 异步编程模型

异步编程模型允许程序在等待某些操作完成时继续执行其他任务，从而提高效率。C++11引入了 <future> 库，支持异步任务的创建和管理。 std::async 函数可以用来启动异步任务，并返回一个 std::future 对象，用于获取任务的结果。

2.1 使用 `std::async`

std::async 函数可以启动一个异步任务，并返回一个 std::future 对象。下面的例子展示了如何使用 std::async 启动异步任务：

#include <iostream>
#include <future>
#include <chrono>

int compute_sum(int a, int b) {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return a + b;
}

int main() {
    std::future<int> sum_future = std::async(compute_sum, 10, 20);

    // 可以在此期间执行其他任务
    std::cout << "Waiting for the result..." << std::endl;

    int sum = sum_future.get(); // 获取结果
    std::cout << "Sum: " << sum << std::endl;

    return 0;
}

2.2 异步任务的回调机制

除了直接获取异步任务的结果外，还可以使用回调机制来处理任务完成后的操作。 std::promise 和 std::future 可以配合使用，实现异步任务的回调机制。下面的例子展示了如何使用 std::promise 和 std::future 实现回调：

#include <iostream>
#include <future>
#include <thread>

void handle_result(std::shared_future<int> fut) {
    int result = fut.get();
    std::cout << "Result: " << result << std::endl;
}

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();

    std::thread t([&]() {
        std::this_thread::sleep_for(std::chrono::seconds(2));
        prom.set_value(42);
    });

    handle_result(fut.share());

    t.join();
    return 0;
}

3. 并发与异步编程的最佳实践

在实际开发中，合理使用并发和异步编程可以显著提升程序的性能和响应速度。以下是一些最佳实践，帮助开发者更好地利用这些特性：

3.1 减少锁的使用

过多的锁会导致性能瓶颈，甚至引发死锁。因此，尽量减少锁的使用，使用无锁数据结构或原子操作代替锁。例如，使用 std::atomic 来实现线程安全的计数器：

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> counter(0);

void increment_counter() {
    for (int i = 0; i < 1000; ++i) {
        counter++;
    }
}

int main() {
    std::thread t1(increment_counter);
    std::thread t2(increment_counter);

    t1.join();
    t2.join();

    std::cout << "Final counter value: " << counter << std::endl;
    return 0;
}

3.2 使用智能指针管理资源

在并发编程中，资源管理尤为重要。使用智能指针（如 std::unique_ptr 和 std::shared_ptr ）可以帮助自动管理资源，避免内存泄漏和其他资源管理问题。下面的例子展示了如何使用智能指针管理动态分配的对象：

#include <iostream>
#include <memory>
#include <thread>

void use_resource(std::shared_ptr<int> ptr) {
    *ptr += 1;
    std::cout << "Resource value: " << *ptr << std::endl;
}

int main() {
    auto resource = std::make_shared<int>(0);
    std::thread t1(use_resource, resource);
    std::thread t2(use_resource, resource);

    t1.join();
    t2.join();

    std::cout << "Final resource value: " << *resource << std::endl;
    return 0;
}

3.3 避免过度使用线程池

线程池可以有效减少线程创建和销毁的开销，但在某些情况下，过度使用线程池可能导致性能下降。因此，应根据实际情况合理配置线程池的大小。下面的例子展示了如何使用线程池管理任务：

#include <iostream>
#include <vector>
#include <thread>
#include <functional>
#include <queue>
#include <mutex>
#include <condition_variable>

class ThreadPool {
public:
    ThreadPool(size_t threads) : stop(false) {
        for (size_t i = 0; i < threads; ++i) {
            workers.emplace_back(
                [this] {
                    for (;;) {
                        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 (std::thread &worker : workers) worker.join();
    }

    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::result_of<F(Args...)>::type> {
        using return_type = typename std::result_of<F(Args...)>::type;

        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );

        std::future<return_type> res = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queue_mutex);

            // don't allow enqueueing after stopping the pool
            if (stop) throw std::runtime_error("enqueue on stopped ThreadPool");

            tasks.emplace([task]() { (*task)(); });
        }
        condition.notify_one();
        return res;
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;

    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

void print_number(int n) {
    std::cout << "Number: " << n << std::endl;
}

int main() {
    ThreadPool pool(4);

    for (int i = 0; i < 10; ++i) {
        pool.enqueue(print_number, i);
    }

    return 0;
}

4. 并发与异步编程的实际应用场景

并发和异步编程在实际开发中有广泛的应用场景。以下是一些典型的应用场景：

4.1 多任务处理

在需要同时处理多个任务的场景下，使用并发编程可以显著提高效率。例如，一个Web服务器可以使用多线程处理多个客户端请求，从而提高响应速度。

4.2 数据处理与计算密集型任务

对于计算密集型任务，如图像处理、机器学习算法等，使用并发编程可以充分利用多核处理器的计算能力，加速任务完成。

应用场景	描述
Web服务器	使用多线程处理多个客户端请求，提高响应速度。
图像处理	利用多核处理器并行处理图像数据，加速处理速度。
数据库查询	使用异步查询避免阻塞主线程，提高查询效率。

4.3 用户界面交互

在图形用户界面（GUI）应用程序中，使用异步编程可以避免阻塞主线程，保持界面的流畅性。例如，在一个视频播放器中，可以使用异步加载视频帧，确保用户界面的响应速度。

5. 并发与异步编程的挑战与解决方案

尽管并发和异步编程带来了诸多好处，但也带来了不少挑战。以下是一些常见的挑战及其解决方案：

5.1 死锁

死锁是并发编程中常见的问题之一，当多个线程互相等待对方持有的资源时发生。可以通过以下方式避免死锁：

资源顺序 ：确保所有线程按照相同的顺序获取资源。
超时机制 ：设置超时机制，避免线程无限期等待。

5.2 数据竞争

数据竞争发生在多个线程同时访问和修改共享资源时。可以通过以下方式避免数据竞争：

互斥锁 ：使用互斥锁保护共享资源。
无锁编程 ：使用无锁数据结构或原子操作。

5.3 线程饥饿

线程饥饿是指某些线程长时间无法获得CPU资源。可以通过以下方式避免线程饥饿：

公平调度 ：使用公平调度算法，确保每个线程都能获得CPU资源。
优先级调整 ：根据任务的优先级调整线程的优先级。

graph TD;
    A[并发与异步编程的挑战] --> B(死锁);
    A --> C(数据竞争);
    A --> D(线程饥饿);
    B --> E[资源顺序];
    B --> F[超时机制];
    C --> G[互斥锁];
    C --> H[无锁编程];
    D --> I[公平调度];
    D --> J[优先级调整];

并发与异步编程是现代C++开发中不可或缺的一部分。通过合理使用这些技术，开发者可以编写出高效、可靠的应用程序。在实际开发中，需要注意避免常见问题，选择合适的技术方案，以充分发挥并发与异步编程的优势。

6. 并发容器与数据结构

在并发编程中，使用专门设计的并发容器和数据结构可以显著简化编程难度并提高性能。C++17引入了更多并发容器，使得开发者能够更方便地处理多线程环境下的数据存储和访问问题。

6.1 `std::shared_mutex`

std::shared_mutex 允许多个线程同时读取共享资源，但只有一个线程可以写入。这对于读多写少的场景非常有用。下面的例子展示了如何使用 std::shared_mutex 保护共享资源：

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

std::shared_mutex rw_mutex;
std::vector<int> shared_data;

void read_data(int id) {
    std::shared_lock<std::shared_mutex> lock(rw_mutex);
    std::cout << "Reader " << id << ": ";
    for (auto& item : shared_data) {
        std::cout << item << " ";
    }
    std::cout << std::endl;
}

void write_data(int id, int value) {
    std::unique_lock<std::shared_mutex> lock(rw_mutex);
    shared_data.push_back(value);
    std::cout << "Writer " << id << " added " << value << std::endl;
}

int main() {
    std::thread readers[5], writers[2];

    for (int i = 0; i < 5; ++i) {
        readers[i] = std::thread(read_data, i);
    }

    for (int i = 0; i < 2; ++i) {
        writers[i] = std::thread(write_data, i, i * 10);
    }

    for (auto& reader : readers) {
        reader.join();
    }

    for (auto& writer : writers) {
        writer.join();
    }

    return 0;
}

6.2 `std::atomic` 与原子操作

std::atomic 提供了一组原子操作，可以在多线程环境下安全地操作共享数据。原子操作可以避免数据竞争，并且性能优于互斥锁。下面的例子展示了如何使用 std::atomic 实现线程安全的计数器：

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> atomic_counter(0);

void increment_atomic_counter() {
    for (int i = 0; i < 1000; ++i) {
        atomic_counter.fetch_add(1, std::memory_order_relaxed);
    }
}

int main() {
    std::thread t1(increment_atomic_counter);
    std::thread t2(increment_atomic_counter);

    t1.join();
    t2.join();

    std::cout << "Final atomic counter value: " << atomic_counter.load() << std::endl;
    return 0;
}

7. 异步任务的组合与协调

在复杂的异步编程场景中，常常需要组合多个异步任务，并协调它们的执行。C++17引入了 std::future 的扩展功能，使得异步任务的组合更加灵活和高效。

7.1 使用 `std::async` 和 `std::future`

std::async 可以启动多个异步任务，并通过 std::future 获取任务的结果。下面的例子展示了如何使用 std::async 启动多个异步任务，并等待所有任务完成：

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

int compute_sum(int a, int b) {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    return a + b;
}

int main() {
    std::vector<std::future<int>> futures;
    for (int i = 0; i < 10; ++i) {
        futures.push_back(std::async(compute_sum, i, i * 2));
    }

    int total_sum = 0;
    for (auto& fut : futures) {
        total_sum += fut.get();
    }

    std::cout << "Total sum: " << total_sum << std::endl;
    return 0;
}

7.2 异步任务的组合

std::future 的扩展功能使得可以组合多个异步任务，并等待所有任务完成。下面的例子展示了如何使用 std::future 的组合功能：

#include <iostream>
#include <future>
#include <tuple>

int task1() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 1;
}

int task2() {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 2;
}

std::string task3() {
    std::this_thread::sleep_for(std::chrono::seconds(3));
    return "Hello";
}

int main() {
    auto fut1 = std::async(task1);
    auto fut2 = std::async(task2);
    auto fut3 = std::async(task3);

    auto combined_futures = std::make_tuple(fut1, fut2, fut3);
    auto result = std::apply([](std::future<int>& f1, std::future<int>& f2, std::future<std::string>& f3) {
        return std::make_tuple(f1.get(), f2.get(), f3.get());
    }, combined_futures);

    std::cout << "Results: " << std::get<0>(result) << ", " << std::get<1>(result) << ", " << std::get<2>(result) << std::endl;
    return 0;
}

8. 并发与异步编程的性能优化

为了进一步提高并发与异步编程的性能，开发者可以采取一些优化措施。以下是一些常见的优化技巧：

8.1 使用高效的同步机制

选择合适的同步机制可以显著影响程序的性能。例如， std::shared_mutex 在读多写少的场景下性能优于传统的互斥锁。下面的例子展示了如何选择合适的同步机制：

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

std::shared_mutex rw_mutex;
std::vector<int> shared_data;

void read_data(int id) {
    std::shared_lock<std::shared_mutex> lock(rw_mutex);
    std::cout << "Reader " << id << ": ";
    for (auto& item : shared_data) {
        std::cout << item << " ";
    }
    std::cout << std::endl;
}

void write_data(int id, int value) {
    std::unique_lock<std::shared_mutex> lock(rw_mutex);
    shared_data.push_back(value);
    std::cout << "Writer " << id << " added " << value << std::endl;
}

int main() {
    std::thread readers[5], writers[2];

    for (int i = 0; i < 5; ++i) {
        readers[i] = std::thread(read_data, i);
    }

    for (int i = 0; i < 2; ++i) {
        writers[i] = std::thread(write_data, i, i * 10);
    }

    for (auto& reader : readers) {
        reader.join();
    }

    for (auto& writer : writers) {
        writer.join();
    }

    return 0;
}

8.2 减少上下文切换

频繁的上下文切换会降低程序的性能。通过合理设计并发任务，减少上下文切换次数可以显著提高性能。例如，使用线程池管理任务可以减少线程创建和销毁的开销。下面的例子展示了如何使用线程池管理任务：

#include <iostream>
#include <vector>
#include <thread>
#include <functional>
#include <queue>
#include <mutex>
#include <condition_variable>

class ThreadPool {
public:
    ThreadPool(size_t threads) : stop(false) {
        for (size_t i = 0; i < threads; ++i) {
            workers.emplace_back(
                [this] {
                    for (;;) {
                        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 (std::thread &worker : workers) worker.join();
    }

    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::result_of<F(Args...)>::type> {
        using return_type = typename std::result_of<F(Args...)>::type;

        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );

        std::future<return_type> res = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queue_mutex);

            // don't allow enqueueing after stopping the pool
            if (stop) throw std::runtime_error("enqueue on stopped ThreadPool");

            tasks.emplace([task]() { (*task)(); });
        }
        condition.notify_one();
        return res;
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;

    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

void print_number(int n) {
    std::cout << "Number: " << n << std::endl;
}

int main() {
    ThreadPool pool(4);

    for (int i = 0; i < 10; ++i) {
        pool.enqueue(print_number, i);
    }

    return 0;
}

8.3 优化内存布局

合理的内存布局可以减少缓存未命中，提高程序的性能。通过使用连续内存布局的数据结构，可以减少缓存未命中。例如，使用 std::vector 代替 std::list 可以提高缓存命中率。下面的例子展示了如何优化内存布局：

#include <iostream>
#include <vector>
#include <list>
#include <chrono>

void benchmark_vector() {
    std::vector<int> vec(1000000);
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < 1000000; ++i) {
        vec[i] = i;
    }
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "Vector benchmark: " << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() << " microseconds" << std::endl;
}

void benchmark_list() {
    std::list<int> lst;
    lst.reserve(1000000);
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < 1000000; ++i) {
        lst.push_back(i);
    }
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "List benchmark: " << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() << " microseconds" << std::endl;
}

int main() {
    benchmark_vector();
    benchmark_list();
    return 0;
}

8.4 并行算法

C++17引入了并行算法，可以在多核处理器上并行执行标准库算法。使用并行算法可以显著提高计算密集型任务的性能。下面的例子展示了如何使用并行算法：

#include <iostream>
#include <vector>
#include <numeric>
#include <execution>

int main() {
    std::vector<int> vec(1000000);
    for (int i = 0; i < 1000000; ++i) {
        vec[i] = i;
    }

    auto sum = std::reduce(std::execution::par, vec.begin(), vec.end());
    std::cout << "Sum: " << sum << std::endl;

    return 0;
}

9. 结合设计模式与并发编程

在并发编程中，合理使用设计模式可以提高代码的可维护性和可扩展性。以下是一些常用的并发编程设计模式：

9.1 生产者-消费者模式

生产者-消费者模式是一种经典的并发编程模式，适用于生产者和消费者之间存在缓冲区的场景。下面的例子展示了如何使用生产者-消费者模式：

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

std::queue<int> buffer;
std::mutex mtx;
std::condition_variable cv;

void producer(int id, int count) {
    for (int i = 0; i < count; ++i) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        int value = i;
        {
            std::lock_guard<std::mutex> lock(mtx);
            buffer.push(value);
        }
        cv.notify_one();
        std::cout << "Producer " << id << " produced " << value << std::endl;
    }
}

void consumer(int id, int count) {
    for (int i = 0; i < count; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [] { return !buffer.empty(); });
        int value = buffer.front();
        buffer.pop();
        lock.unlock();
        std::cout << "Consumer " << id << " consumed " << value << std::endl;
    }
}

int main() {
    std::thread producers[2], consumers[2];

    for (int i = 0; i < 2; ++i) {
        producers[i] = std::thread(producer, i, 5);
        consumers[i] = std::thread(consumer, i, 5);
    }

    for (auto& producer : producers) {
        producer.join();
    }

    for (auto& consumer : consumers) {
        consumer.join();
    }

    return 0;
}

9.2 读写锁模式

读写锁模式适用于读多写少的场景，允许多个线程同时读取共享资源，但只有一个线程可以写入。下面的例子展示了如何使用读写锁模式：

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

std::shared_mutex rw_mutex;
std::vector<int> shared_data;

void read_data(int id) {
    std::shared_lock<std::shared_mutex> lock(rw_mutex);
    std::cout << "Reader " << id << ": ";
    for (auto& item : shared_data) {
        std::cout << item << " ";
    }
    std::cout << std::endl;
}

void write_data(int id, int value) {
    std::unique_lock<std::shared_mutex> lock(rw_mutex);
    shared_data.push_back(value);
    std::cout << "Writer " << id << " added " << value << std::endl;
}

int main() {
    std::thread readers[5], writers[2];

    for (int i = 0; i < 5; ++i) {
        readers[i] = std::thread(read_data, i);
    }

    for (int i = 0; i < 2; ++i) {
        writers[i] = std::thread(write_data, i, i * 10);
    }

    for (auto& reader : readers) {
        reader.join();
    }

    for (auto& writer : writers) {
        writer.join();
    }

    return 0;
}

9.3 信号量模式

信号量模式用于限制访问共享资源的线程数量。下面的例子展示了如何使用信号量模式：

#include <iostream>
#include <thread>
#include <semaphore>

std::binary_semaphore semaphore(3);

void limited_access(int id) {
    semaphore.acquire();
    std::cout << "Thread " << id << " acquired semaphore" << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Thread " << id << " releasing semaphore" << std::endl;
    semaphore.release();
}

int main() {
    std::thread threads[5];

    for (int i = 0; i < 5; ++i) {
        threads[i] = std::thread(limited_access, i);
    }

    for (auto& thread : threads) {
        thread.join();
    }

    return 0;
}

9.4 异步任务队列模式

异步任务队列模式适用于需要将任务放入队列并在后台处理的场景。下面的例子展示了如何使用异步任务队列模式：

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

std::queue<std::function<void()>> task_queue;
std::mutex queue_mutex;
std::condition_variable queue_cv;
bool stop = false;

void worker_thread() {
    while (!stop) {
        std::function<void()> task;
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            queue_cv.wait(lock, [] { return !task_queue.empty() || stop; });
            if (stop && task_queue.empty()) return;
            task = std::move(task_queue.front());
            task_queue.pop();
        }
        task();
    }
}

std::future<void> enqueue_task(std::function<void()> task) {
    std::packaged_task<void()> packaged_task(task);
    std::future<void> task_future = packaged_task.get_future();
    {
        std::lock_guard<std::mutex> lock(queue_mutex);
        task_queue.push(std::move(packaged_task));
    }
    queue_cv.notify_one();
    return task_future;
}

int main() {
    std::thread worker(worker_thread);

    enqueue_task([] { std::cout << "Task 1" << std::endl; }).get();
    enqueue_task([] { std::cout << "Task 2" << std::endl; }).get();
    enqueue_task([] { std::cout << "Task 3" << std::endl; }).get();

    stop = true;
    queue_cv.notify_one();
    worker.join();

    return 0;
}

graph TD;
    A[常用并发编程设计模式] --> B(生产者-消费者模式);
    A --> C(读写锁模式);
    A --> D(信号量模式);
    A --> E(异步任务队列模式);
    B --> F[缓冲区];
    C --> G[读多写少];
    D --> H[限制线程数量];
    E --> I[任务队列];