Modern C++ on kenji.blog

C++多线程编程入门与异步处理（std::async）

Sat, 12 Sep 2026 08:00:00 +0900

在现代软件开发中，为了最大限度地发挥多核CPU的性能，多线程编程是不可或缺的。C++从C++11开始引入了多线程和异步处理的API（<thread>, <mutex>, <condition_variable>, <future>）作为标准库，使得开发者无需编写依赖于平台的代码（如POSIX线程或Windows API），即可实现可移植且安全的并发处理。此外，随着C++14、C++17和C++20的不断版本升级，还添加了如 std::scoped_lock 和 std::jthread 等更安全、更高级的功能。

本文将从C++多线程编程的基础开始，到防止数据竞争的同步机制，再到现代的异步处理（std::async）以及线程池的概念，结合详细的代码示例进行全面彻底的讲解。

1. 并发处理的基础与阿姆达尔定律

多线程化的最大目的是“提升性能”，但这并不意味着可以将整个程序都并行化。这里非常重要的一点就是阿姆达尔定律 (Amdahl’s Law)。

阿姆达尔定律是一个预测模型，用于预测在将程序的一部分进行并行化和加速后，整个系统的性能能提升多少。

$$ S(N) = \frac{1}{(1 - P) + \frac{P}{N}} $$

$S(N)$ : 理论上的最大加速比
$P$ : 整个程序中可以被并行化的部分所占的比例 (0 ≤ $P$ ≤ 1)
$N$ : 处理器（线程）的数量

这个公式揭示了一个重要的事实：“无论增加多少个处理器 $N$，无法并行化的串行部分 $(1 - P)$ 终将成为瓶颈，加速比是存在上限的”。例如，即使程序中有 $90\%$ 可以并行化（$P = 0.9$），只要剩下的 $10\%$ 是串行处理的，那么即使使用无数个处理器，最多也只能加速 $10$ 倍（$S(\infty) = 1 / 0.1$）。

因此，在使用C++进行多线程编程时，不仅需要增加线程，还需要一种尽量减少串行处理部分（如锁竞争和同步开销等）的设计。

2. 线程的基础：`std::thread` 与 `std::jthread` (C++20)

传统的 `std::thread` (C++11)

C++11引入的 std::thread 是最基本的类，用于在新线程中执行函数或Lambda表达式。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <iostream>
#include <thread>

void workerFunction(int id) {
 std::cout << "Worker " << id << " is running on thread "
 << std::this_thread::get_id() << std::endl;
}

int main() {
 std::cout << "Main thread id: " << std::this_thread::get_id() << std::endl;

 // 创建并开始执行线程
 std::thread t1(workerFunction, 1);

 // 使用Lambda表达式创建线程
 std::thread t2([](int id) {
 std::cout << "Lambda Worker " << id << " is running." << std::endl;
 }, 2);

 // 等待线程结束（join）
 t1.join();
 t2.join();

 std::cout << "All threads completed." << std::endl;
 return 0;
}

std::thread 需要注意的是：在被销毁之前，必须调用 join() 或 detach()。如果两者都没有被调用，而触发了 std::thread 的析构函数，则会调用 std::terminate() 导致程序崩溃。为了确保异常安全性，我们以前需要自己编写使用了RAII模式的包装类。

现代的 `std::jthread` (C++20)

在C++20中，引入了解决这些缺点的 std::jthread (joining thread)。std::jthread 会在析构函数中自动调用 join()，因此即使发生异常，也能安全地等待线程结束。此外，它还具备通过 std::stop_token 协作取消线程的功能。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <iostream>
#include <thread>
#include <chrono>

int main() {
 // C++20: std::jthread
 // 通过将 std::stop_token 作为第一个参数接收，可以检测到取消请求
 std::jthread jt([](std::stop_token stoken) {
 while (!stoken.stop_requested()) {
 std::cout << "Working..." << std::endl;
 std::this_thread::sleep_for(std::chrono::milliseconds(500));
 }
 std::cout << "Stop requested. Exiting thread." << std::endl;
 });

 std::this_thread::sleep_for(std::chrono::seconds(2));

 // 明确发出取消请求
 jt.request_stop();

 // 由于 jthread 的析构函数会自动 join，因此不需要手动调用 join()
 return 0;
}

3. 避免数据竞争与同步：互斥锁与锁定

当多个线程同时访问同一个内存区域（如变量），并且至少有一个线程进行写入操作时，就会发生数据竞争 (Data Race)。在C++标准中，数据竞争会导致未定义行为 (Undefined Behavior)。为了防止这种情况，必须使用 std::mutex 进行互斥控制。

`std::mutex` 与 `std::lock_guard`

不建议手动调用原生的 std::mutex::lock() 和 unlock()，因为在发生异常时可能无法调用 unlock()，从而带来死锁的风险。在C++中，我们使用基于RAII模式的 std::lock_guard (C++11) 或 std::scoped_lock (C++17)。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


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

std::mutex g_mutex;
int g_counter = 0;

void incrementCounter(int iterations) {
 for (int i = 0; i < iterations; ++i) {
 // 在离开作用域时会自动 unlock
 std::lock_guard<std::mutex> lock(g_mutex);
 ++g_counter;
 }
}

int main() {
 std::vector<std::thread> threads;
 for (int i = 0; i < 10; ++i) {
 threads.emplace_back(incrementCounter, 10000);
 }

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

 std::cout << "Final counter value: " << g_counter << std::endl;
 // 结果会如期达到 100000
 return 0;
}

`std::unique_lock`

std::lock_guard 是简单的基于作用域的锁，但如果需要更灵活的控制（如延迟锁定、带时间限制的锁定、中途解锁等），则应使用 std::unique_lock。在接下来要讲解的 std::condition_variable 中，std::unique_lock 是必不可少的。

4. 线程间通信：`std::condition_variable`

如果需要实现“生产者-消费者模式 (Producer-Consumer Pattern)”等机制，即一个线程等待某个特定条件满足，而另一个线程在条件满足时发送通知，就可以使用 std::condition_variable。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


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

std::mutex g_mtx;
std::condition_variable g_cv;
std::queue<int> g_dataQueue;
bool g_isFinished = false;

void producer() {
 for (int i = 1; i <= 5; ++i) {
 std::this_thread::sleep_for(std::chrono::milliseconds(200));
 {
 std::lock_guard<std::mutex> lock(g_mtx);
 g_dataQueue.push(i);
 std::cout << "Produced: " << i << std::endl;
 }
 g_cv.notify_one(); // 通知消费者
 }

 {
 std::lock_guard<std::mutex> lock(g_mtx);
 g_isFinished = true;
 }
 g_cv.notify_one(); // 通知结束
}

void consumer() {
 while (true) {
 std::unique_lock<std::mutex> lock(g_mtx);
 // 等待条件满足（队列非空，或已设置结束标志）
 // 为防止虚假唤醒 (Spurious Wakeup)，使用 Lambda 表达式指定条件
 g_cv.wait(lock, []{ return !g_dataQueue.empty() || g_isFinished; });

 while (!g_dataQueue.empty()) {
 int val = g_dataQueue.front();
 g_dataQueue.pop();
 // 解锁以执行耗时操作（这里仅作为输出）
 lock.unlock();
 std::cout << "Consumed: " << val << std::endl;
 lock.lock(); // 再次获取锁
 }

 if (g_isFinished && g_dataQueue.empty()) {
 break;
 }
 }
}

int main() {
 std::thread t1(producer);
 std::thread t2(consumer);
 t1.join();
 t2.join();
 return 0;
}

在这个例子中，std::condition_variable::wait 会让线程进入休眠状态直到条件满足，从而避免了CPU资源的无效消耗（忙等待）。

5. 高度抽象的异步处理：`std::future`, `std::promise`, `std::async`

到目前为止介绍的 std::thread 和 std::mutex 虽然功能强大，但它们实际上只是将OS的底层线程机制直接搬到了C++中。在处理获取结果或传播异常时，代码往往会变得十分繁琐。如果想要实现带有返回值的并发处理，或者更高级别的异步处理，可以使用 <future> 头文件中的功能。

`std::promise` 与 `std::future`

std::promise 代表“设置”结果的一方，而 std::future 代表“接收”结果的一方。它们在线程之间充当传递结果或异常的安全通道。

使用 `std::async` 进行基于任务的并发处理

在C++中，执行异步任务最推荐的方法是使用 std::async。std::async 会异步执行任务，并返回一个用于获取该结果的 std::future。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


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

int complexCalculation(int x) {
 std::cout << "Calculation started on thread: "
 << std::this_thread::get_id() << std::endl;
 std::this_thread::sleep_for(std::chrono::seconds(2));
 if (x < 0) {
 throw std::invalid_argument("x must be positive");
 }
 return x * 42;
}

int main() {
 std::cout << "Main thread id: " << std::this_thread::get_id() << std::endl;

 // 指定 std::launch::async 强制在另一个线程中执行
 std::future<int> resultFuture = std::async(std::launch::async, complexCalculation, 10);

 std::cout << "Main thread is doing other work..." << std::endl;

 try {
 // 调用 get() 时，会阻塞当前线程直到计算完成
 int result = resultFuture.get();
 std::cout << "Result: " << result << std::endl;
 } catch (const std::exception& e) {
 std::cerr << "Exception caught: " << e.what() << std::endl;
 }

 return 0;
}

std::async 的行为可以通过以下时序图来表示。

sequenceDiagram participant Main as "主线程" participant Async as "std::async 工作线程" Main->>Async: "std::async(std::launch::async, ...)" activate Async Note over Main: "执行其他工作..." Main->>Async: "future.get() (阻塞直到准备就绪)" Note right of Async: "计算中..." Async-->>Main: "返回结果或抛出异常" deactivate Async

std::async 的第一个参数是启动策略 (Launch Policy)，有两种类型：

std::launch::async: 强制创建新线程（或从线程池中分配）并异步执行。
std::launch::deferred: 延迟求值。在调用 future.get() 或 future.wait() 时，在调用方线程中同步执行。

如果是默认情况（未指定），则由具体实现决定，系统会根据负载情况选择其中之一。如果想要确保异步执行，请明确指定 std::launch::async。

6. 线程池（Thread Pool）的概念

如果每次都调用 std::async，或在循环中每次都创建和销毁 std::thread，那么线程的上下文切换和OS资源分配带来的开销将变得不可忽视。特别是在处理大量小任务（Fine-grained tasks）时，使用线程池 (Thread Pool) 是必不可少的。

线程池是一种架构，在应用程序启动时预先创建一定数量的工作线程（Worker），将任务存入队列 (Queue) 中，然后由空闲的工作线程依次取出任务并处理。

尽管C++标准库（截至C++23）中尚不存在标准的线程池类，但通过组合 std::thread, std::mutex, std::condition_variable, std::function, std::packaged_task，可以用几十行代码实现一个高效的线程池。在实际应用中，通常也会使用 Boost.Asio 的异步I/O或第三方库。

7. 关于性能与可扩展性的思考

为了在多线程编程中发挥出最高性能，不仅要关注代码的并行化，还必须注意硬件架构。

伪共享 (False Sharing): 即使多个线程分别更新不同的变量，如果这些变量被分配在CPU的同一个缓存行（通常为64字节）中，也会为了维持缓存一致性而产生无谓的内存同步，导致性能急剧下降。为了防止这种情况，需要使用 alignas 说明符将变量对齐到缓存行的边界。
无锁 (Lock-Free) 与 std::atomic: 为了避免互斥锁锁定/解锁的开销，可以考虑引入使用 <atomic> 的原子操作（如Compare-And-Swap等）以及无锁数据结构。但是，这需要对内存序 (std::memory_order) 有着正确的理解，且实现难度非常高，通常只有在经过谨慎的性能测试并判断确有必要时才应引入。

8. 总结

本文从基础到最新的C++20功能，对C++中的多线程与异步编程进行了讲解。重点如下：

基本上使用 std::async: 对于单次的异步任务或需要返回结果的并发处理，使用 std::async 和 std::future 比手动管理线程更安全。
使用 std::jthread 进行线程管理: 对于长期在后台运行的线程，应使用C++20的 std::jthread，以保证安全的终止处理。
利用RAII进行同步: 为了防止数据竞争，在使用互斥锁时必须始终通过 std::lock_guard 或 std::unique_lock 来进行。
注意开销: 避免过度创建线程，并根据需要引入线程池架构。

并发处理相关的Bug（如死锁、数据竞争）重现率低，属于最难调试的一类。我们应该时刻保持线程安全的意识，选择合适的标准库工具，从而利用现代C++开发出健壮且高速的系统。

防止内存泄漏的智能指针（std::unique_ptr / shared_ptr）运用指南

Sat, 12 Sep 2026 07:00:00 +0900

在C++中，内存管理长久以来都是开发者面临的最大挑战之一。依赖于手动 new 和 delete 的传统内存管理风格，成为了引发内存泄漏、悬垂指针以及重复释放等严重Bug的温床。然而，随着Modern C++（C++11及以后版本）的出现，情况发生了翻天覆地的变化。其核心便是“智能指针（Smart Pointers）”。

本文将极其详细地解说 std::unique_ptr、std::shared_ptr 以及 std::weak_ptr 的机制与高级运用技巧，它们是根除内存泄漏、实现安全且高效的资源管理的强大工具。我们将结合其内部实现（控制块和原子操作）、对性能的影响、以及基于数学模型的引用计数公式化来进行阐述。

1. 引入：C++内存管理的黑暗时代与Modern C++的黎明

在过去的C++开发中，在堆上分配的内存必须由开发者自己负责释放。

1
2
3
4
5
6
7
8


void legacy_function() {
 int* ptr = new int(10);
 // ... 某些处理 ...
 if (some_condition) {
 return; // 发生内存泄漏！delete没有被调用
 }
 delete ptr;
}

在上述代码中，如果发生异常或者提前返回，delete 将被跳过，从而引发内存泄漏。为了防止这种情况发生，出现了一种范式叫做“RAII（Resource Acquisition Is Initialization，资源获取即初始化）”。RAII是一种将资源的获取与对象的初始化（构造函数）绑定，将资源的释放与对象的销毁（析构函数）绑定的手法。智能指针正是将这种RAII惯用法应用于内存管理的标准库类栈。

2. `std::unique_ptr`：零开销的独占所有权

std::unique_ptr 是一种对动态分配的对象拥有“独占所有权（Exclusive Ownership）”的智能指针。对于某个资源，同一时刻只能有一个 unique_ptr 拥有它。

2.1 零开销原则

std::unique_ptr 最大的魅力在于其性能。在没有自定义删除器的默认状态下，std::unique_ptr 的大小与裸指针（Raw Pointer）完全一致。它不包含任何不必要的成员变量，也没有使用虚函数。通过编译器的优化，通过 unique_ptr 进行的访问将被展开为与裸指针等效的汇编代码。

2.2 所有权的转移与 `std::move`

由于具有独占所有权，std::unique_ptr 无法被复制（拷贝构造函数和拷贝赋值运算符已被 delete）。要将所有权转移给另一个 unique_ptr，需要使用 std::move 来利用移动语义（Move Semantics）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <iostream>
#include <memory>

class Resource {
public:
 Resource() { std::cout << "Resource acquired\n"; }
 ~Resource() { std::cout << "Resource destroyed\n"; }
 void do_something() { std::cout << "Doing something\n"; }
};

void process_resource(std::unique_ptr<Resource> ptr) {
 ptr->do_something();
 // 离开作用域时 ptr 被销毁，Resource 也随之释放
}

int main() {
 std::unique_ptr<Resource> my_ptr = std::make_unique<Resource>();

 // process_resource(my_ptr); // 错误：不可复制
 process_resource(std::move(my_ptr)); // 转移所有权

 if (!my_ptr) {
 std::cout << "my_ptr is now empty.\n";
 }
 return 0;
}

下方的Mermaid图展示了通过 std::move 转移所有权的概念。

2.3 自定义删除器的实现

在封装C语言的旧API（例如 FILE* 或套接字等）时，需要调用 delete 以外的函数（如 fclose）来释放内存。std::unique_ptr 可以通过第二个模板参数指定自定义删除器。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <cstdio>
#include <memory>

// 用于自定义删除器的仿函数
struct FileDeleter {
 void operator()(FILE* fp) const {
 if (fp) {
 std::cout << "Closing file.\n";
 std::fclose(fp);
 }
 }
};

using UniqueFile = std::unique_ptr<FILE, FileDeleter>;

int main() {
 UniqueFile file(std::fopen("test.txt", "w"));
 if (file) {
 std::fputs("Hello, Smart Pointers!", file.get());
 }
 // 作用域结束时将调用 FileDeleter 执行 fclose
 return 0;
}

如果使用函数指针或Lambda表达式作为自定义删除器，可能会增加 unique_ptr 的大小。但如上所述使用无状态的函数对象（Functor），借助C++的**EBCO（Empty Base Class Optimization，空基类优化）**或C++20的 [[no_unique_address]]，其大小不会比裸指针增加（维持了零开销）。

3. `std::shared_ptr`：共享所有权与控制块

std::shared_ptr 是一种允许多个指针共享同一个对象所有权的智能指针。当最后一个拥有它的 shared_ptr 被销毁时，其管理的对象才会被释放。

3.1 内部架构：控制块

std::shared_ptr 在管理对象的指针之外，还会在堆上分配并共享一个被称为**控制块（Control Block）**的元数据。控制块包含以下信息：

强引用计数（Strong Count）：拥有该对象的 shared_ptr 的数量。当它变为0时，对象将被销毁。
弱引用计数（Weak Count）：监视该对象的 weak_ptr 的数量。当强引用计数和弱引用计数都变为0时，控制块自身将被释放。
自定义删除器和分配器（如果指定的话）。

因此，std::shared_ptr 对象本身的大小通常是裸指针的两倍（一个指向对象的指针，一个指向控制块的指针）。

3.2 性能与原子操作

控制块内的引用计数为了在多线程环境下也能安全地进行增减，是通过**原子操作（Atomic Operations）**来实现的。

在x86/x64架构中，引用计数的增减会使用类似 lock xadd 的原子指令。与普通的整数加法相比，这会带来数十个时钟周期的开销。因此，如果以传值的方式将 shared_ptr 传递给函数，每次复制都会发生原子的递增和递减，从而导致性能下降。

最佳实践：在将 shared_ptr 传递给函数时，除非需要共享所有权，否则应该以 const std::shared_ptr<T>&（const引用）的方式传递，或者传递裸指针/引用。

3.3 `std::make_shared` vs `new`

在创建 shared_ptr 时，应尽可能使用 std::make_shared。这有两个重要原因：

内存分配优化：使用 new 会发生两次堆内存分配：一次是对象本身的分配，另一次是控制块的分配。而使用 std::make_shared，可以通过一次堆内存分配同时分配包含两者的一大块内存，这也能提升缓存效率。
异常安全性：在C++17之前的标准中，函数参数的求值顺序是未指定的。如果将在 new 中分配的指针传递给 shared_ptr 的构造函数之前，其他参数求值时发生了异常，就会有内存泄漏的风险。make_shared 则完全避免了这个问题。

1
2
3
4
5


// 应该避免的写法（两次内存分配）
std::shared_ptr<MyClass> ptr1(new MyClass());

// 推荐的写法（一次内存分配）
std::shared_ptr<MyClass> ptr2 = std::make_shared<MyClass>();

4. `std::weak_ptr`：打破循环引用与监视

共享所有权有一个致命的弱点，即“循环引用（Circular References）”。如果对象A和对象B相互之间通过 shared_ptr 互相指向对方，它们的强引用计数将至少保持为1，直到程序结束也不会变为0，从而导致内存泄漏。

graph TD subgraph "循环引用（内存泄漏）" A["对象 A"] -->|"shared_ptr (强引用=1)"| B["对象 B"] B -->|"shared_ptr (强引用=1)"| A end

4.1 使用 `std::weak_ptr` 打破循环

解决这个问题的办法是使用 std::weak_ptr。weak_ptr 由 shared_ptr 创建，用来引用对象，但它不会增加强引用计数（Strong Count）。相反，它会增加弱引用计数（Weak Count）。通过这种方式，可以在不拥有所有权的情况下“监视”对象。

graph TD subgraph "打破循环引用" C["对象 A"] -->|"shared_ptr (强引用=1)"| D["对象 B"] D -.->|"weak_ptr (弱引用=1)"| C end

4.2 通过 `lock()` 方法进行安全访问

weak_ptr 没有直接访问对象的运算符（如 -> 或 *）。这是因为目标对象可能已经被销毁了。为了安全地访问，需要调用 lock() 方法来临时获取一个 shared_ptr。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#include <iostream>
#include <memory>

class Node {
public:
 std::string name;
 std::shared_ptr<Node> next;
 std::weak_ptr<Node> prev; // 使用 weak_ptr 防止循环引用

 Node(const std::string& n) : name(n) { std::cout << "Created " << name << "\n"; }
 ~Node() { std::cout << "Destroyed " << name << "\n"; }
};

int main() {
 auto nodeA = std::make_shared<Node>("A");
 auto nodeB = std::make_shared<Node>("B");

 nodeA->next = nodeB;
 nodeB->prev = nodeA;

 // 从 weak_ptr 获取 shared_ptr 来进行访问
 if (auto locked_prev = nodeB->prev.lock()) {
 std::cout << "Node B's prev is " << locked_prev->name << "\n";
 } else {
 std::cout << "Node B's prev is already destroyed.\n";
 }

 return 0; // nodeA 和 nodeB 会被正确销毁
}

5. 多线程环境下的共享所有权限制

关于 shared_ptr 的线程安全性，经常会被误解：“控制块内引用计数的更新是线程安全的”，但是“对 shared_ptr 对象本身的读写不是线程安全的”。

安全的操作：多个线程分别读写各自独立的 shared_ptr 实例（虽然它们共享同一个控制块）。
数据竞争（危险）：多个线程同时对完全相同的 shared_ptr 实例进行读写。

如果需要在多个线程之间共享同一个实例，则需要使用 std::atomic<std::shared_ptr<T>>（C++20）或通过互斥锁（std::mutex）进行保护。

6. 引用计数的数学公式化

如果在数学上表达控制块中生命周期的状态转换，如下所示。设时刻 $t$ 的强引用计数（Strong Count）为 $S(t)$，弱引用计数（Weak Count）为 $W(t)$。

初始状态（make_shared 之后）：

$$ S(0) = 1, \quad W(0) = 0 $$

当发生复制（复制 shared_ptr）时：

$$ S(t_{next}) = S(t) + 1 $$

管理对象（Managed Object）被销毁的条件：

$$ \lim_{t \to t_d} S(t) = 0 $$

控制块（Control Block）自身从内存中释放的条件：

$$ S(t) = 0 \quad \land \quad W(t) = 0 $$

即，

$$ S(t) + W(t) = 0 $$

如这些公式所示，只要 weak_ptr 继续存在（$W(t) > 0$），即使管理对象已经被销毁，为控制块分配的一小块内存空间也将继续保留。这在某些情况下成为 make_shared 的唯一缺点（由于管理对象的内存和控制块是一体化的，如果还有弱引用存在，管理对象占据的巨大内存空间也不会退还给系统），但在一般情况下，make_shared 在性能上的优势占据压倒性地位。

7. 结论

Modern C++ 中的内存管理早已不是那个手动管理 new/delete 的时代了。

在默认情况下，请始终使用 std::unique_ptr，在享受零开销带来的好处的同时，将明确的所有权引入设计。
只有在真正需要在多个所有者之间共享生命周期时，才应使用 std::shared_ptr，并且使用 std::make_shared 来创建它。
在可能发生共享环（循环引用）的数据结构或观察者模式的实现中，请充分利用 std::weak_ptr 来防患于未然，避免内存泄漏。

通过深刻理解智能指针，并在合适的场景下灵活运用，就能在不牺牲任何 C++ 性能的前提下，构建出安全且健壮的软件架构。

Modern C++ on kenji.blog

C++多线程编程入门与异步处理（std::async）

1. 并发处理的基础与阿姆达尔定律

2. 线程的基础：std::thread 与 std::jthread (C++20)

传统的 std::thread (C++11)

现代的 std::jthread (C++20)

3. 避免数据竞争与同步：互斥锁与锁定

std::mutex 与 std::lock_guard

std::unique_lock

4. 线程间通信：std::condition_variable

5. 高度抽象的异步处理：std::future, std::promise, std::async

std::promise 与 std::future

使用 std::async 进行基于任务的并发处理