蓝桥杯c++：STL中的并发容器与算法

# 1. 蓝桥杯c++：STL中的并发容器与算法

## 一、理解STL并发容器

- 1.1 什么是并发容器？
- 1.2 STL中的标准容器与并发容器的对比
- 1.3 使用STL并发容器的优势和注意事项

### 1.1 什么是并发容器？

并发容器是STL中提供的一种特殊容器，用于在多线程环境下安全地存储和管理数据。它能够保证在多线程并发访问时线程安全，不会出现数据竞争的问题。常见的并发容器包括`std::concurrent_queue`、`std::concurrent_unordered_map`等，能够在多线程编程中提供高效的数据共享和访问方式。

### 1.2 STL中的标准容器与并发容器的对比

下表对比了STL中的标准容器和并发容器的主要区别：

| 类别 | 标准容器 | 并发容器 |
|------------|------------------|--------------------------|
| 线程安全性 | 需要额外加锁保护 | 在多线程环境下线程安全 |
| 性能 | 可能存在竞争慢化 | 适用于高并发读写场景 |
| 接口设计 | 标准接口 | 针对并发场景增加了接口 |

### 1.3 使用STL并发容器的优势和注意事项

使用STL并发容器的优势包括：
- 提供了线程安全的容器访问方式，简化了多线程编程；
- 在高并发读写场景下具有良好的性能表现；
- 避免了手动管理锁的复杂性，减少了开发难度。

在使用STL并发容器时需要注意的事项有：
- 仔细阅读文档，了解不同容器的特性和适用场景；
- 避免在遍历容器时修改数据，以免出现迭代器失效等问题；
- 谨慎处理异常，确保在异常情况下不会导致数据不一致。

以上是关于STL并发容器的基本概念、区别以及使用优势和注意事项的介绍。接下来我们将深入探讨STL中的线程安全容器。

# 2. STL中的线程安全容器

- **2.1 std::shared_mutex的使用方法与注意事项**
在多线程编程中，std::shared_mutex 是一种实现读写锁（shared lock）的数据结构。它允许多个线程同时读取共享数据，但只允许一个线程写入数据。下表总结了其常用方法：

| 方法 | 描述 |
|---------------|--------------------------------------------|
| lock_shared() | 获取共享锁，允许多个线程同时进行读操作 |
| unlock_shared()| 释放共享锁 |
| lock() | 获取排他锁，用于写操作，会阻塞其他线程的读写操作 |
| unlock() | 释放排他锁 |
示例代码：

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

  std::shared_mutex mtx;
  int shared_data = 0;

  void read_data() {
      std::shared_lock<std::shared_mutex> lock(mtx);
      std::cout << "Shared data: " << shared_data << std::endl;
  }

  void write_data(int value) {
      std::unique_lock<std::shared_mutex> lock(mtx);
      shared_data = value;
  }

  int main() {
      std::thread reader1(read_data);
      std::thread reader2(read_data);
      std::thread writer(write_data, 42);

      reader1.join();
      reader2.join();
      writer.join();

      return 0;
  }

注：以上代码演示了如何使用 std::shared_mutex 进行读写操作，保证了数据的一致性和并发访问的安全性。

- **2.2 std::atomic的实现机制及应用场景**

std::atomic 为 C++11 中引入的类型，用于实现原子操作。它保证了多个线程对同一数据的读写操作是原子的，避免了数据竞争和数据不一致的问题。下面是 std::atomic 常见的应用场景：

- 在并发队列中，使用 std::atomic 实现原子的入队和出队操作；
- 在计数器场景中，使用 std::atomic 实现原子的自增、自减操作；
- 在标记数据是否被处理的场景中，使用 std::atomic 保证原子性操作。

示例代码：

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

  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;
  }

注：上述代码展示了如何使用 std::atomic 实现线程安全的计数器，避免了多线程并发操作导致的数据竞争问题。

graph LR
    A[开始] --> B{条件判断}
    B -->|是| C[执行操作1]
    B -->|否| D[执行操作2]
    C --> E[结束]
    D --> E

# 3. 使用STL算法处理并发任务

- 3.1 std::async与std::launch的区别与联系
- 3.2 std::packaged_task的用法及实现原理
- 3.3 使用std::thread实现自定义并发算法

### 3.1 std::async与std::launch的区别与联系

在并发编程中，使用 `std::async` 可以异步执行任务，并且通过指定 `std::launch` 参数来控制任务的执行方式。

下表列出了 `std::launch` 参数的不同取值及其含义：

| `std::launch` 参数 | 含义 |
| ------------------------ | ------------------------------------------------------------ |
| `std::launch::deferred` | 延迟执行任务，直到调用其 `get()` 或 `wai