C++11 std::thread 进阶指南：从核心机制到实战避坑

1. 项目概述为什么我们需要深入理解std::thread如果你已经写过一些C代码尤其是涉及到需要同时处理多个任务的程序比如一个需要一边响应用户界面操作、一边在后台下载文件的桌面应用或者一个需要同时服务成百上千个网络连接的高性能服务器那么你肯定对“多线程”这个概念不陌生。在C11标准之前C语言本身并没有提供标准的线程支持开发者们不得不依赖操作系统提供的原生API如Windows的CreateThread、Linux的pthread_create或者第三方库如Boost.Thread来编写多线程程序。这不仅让代码的可移植性变得很差也让多线程编程的门槛高了不少。C11带来的std::thread正是为了解决这个问题。它把线程抽象成了一个标准的类让你可以用创建对象一样简单的方式来创建和管理线程。这听起来很棒对吧但就像任何强大的工具一样用好了事半功倍用错了则可能带来灾难性的后果——数据竞争、死锁、资源泄漏这些多线程的“经典”问题并不会因为使用了标准库就自动消失。标题里的“进阶”二字恰恰点明了我们今天的重点不是简单地知道std::thread t(func);和t.join();而是要深入它的五脏六腑搞清楚每一个构造、每一个成员函数背后的含义、使用场景以及那些容易踩进去的坑。我会结合我这些年实际项目里用到的、调试过的案例带你从“会用”走向“精通”让你写的多线程代码既高效又稳健。2. std::thread的核心机制与设计哲学在直接上手写代码之前我们有必要先理解std::thread这个类的一些基本设计原则。这能帮助我们在后续遇到各种奇怪现象时知道该从哪里寻找答案。2.1 线程的所有权与移动语义这是理解std::thread行为的关键。一个std::thread对象并不等同于一个线程它更像是一个线程的“句柄”或“管理者”。这个对象本身是可移动moveable但**不可复制non-copyable**的。这意味着什么想象一下线程是一个在后台独立运行的工人而std::thread对象是你手里用来和这个工人通信的对讲机。对讲机std::thread对象本身可以换手移动但不能被克隆复制。如果你把对讲机给了别人移动赋值你自己就没有了不能再通过它指挥工人。这个设计强制保证了线程资源的唯一所有权避免了多个对象试图管理同一个线程而导致的混乱。所以当你看到std::thread的拷贝构造函数和拷贝赋值运算符被标记为 delete时不要惊讶这是故意为之。你需要习惯使用移动语义来传递线程对象的所有权。void task() { /* ... */ } std::thread t1(task); // t1拥有一个新线程的所有权 // std::thread t2 t1; // 错误禁止拷贝 std::thread t2 std::move(t1); // 正确移动语义t1变为空线程对象所有权转移给t2 if (!t1.joinable()) { std::cout “t1现在不关联任何线程是空的。” std::endl; } t2.join(); // 由t2来等待线程结束2.2 Joinable状态线程对象的生命线一个std::thread对象可能处于两种状态之一可汇合joinable或不可汇合non-joinable。可汇合joinable该对象正管理着一个活跃的或已结束但尚未被处理的执行线程。简单说它“绑定”了一个实实在在的线程。不可汇合non-joinable对象没有关联任何线程。这包括默认构造的std::thread对象空的。已被移动走的对象所有权转移后原对象变空。已经调用过join()或detach()的对象。这里有一条至关重要的规则如果一个可汇合joinable的std::thread对象在析构时仍然处于可汇合状态程序会调用std::terminate()立即终止这是新手最容易犯的致命错误之一。编译器不会在编译期报错但运行时程序会突然崩溃。{ std::thread t([]{ std::cout “临时线程\n”; }); // 作用域结束t被销毁。如果此时t仍是joinable的既没join也没detach程序terminate } // 危险区域因此你必须在线程对象离开作用域前明确地做出选择要么join()等待它完成要么detach()让它成为后台守护线程。这就是所谓的“线程对象的生命周期管理”。2.3 参数传递值、引用与移动向线程函数传递参数看似简单实则暗藏玄机。构造函数template class Fn, class... Args explicit thread(Fn fn, Args... args);使用了完美转发但它的行为需要仔细理解。默认按值传递参数会被拷贝到线程的内部存储中然后传递给线程函数。即使你传递了一个左值它也会被拷贝。int x 42; std::thread t([](int val) { std::cout val; }, x); // x被拷贝线程内修改val不影响外部的x传递引用必须使用std::ref或std::cref来包装引用。这是告诉std::thread“不要拷贝这个参数请传递它的引用”。int x 42; std::thread t([](int val) { val 100; }, std::ref(x)); // 传递x的引用 t.join(); std::cout x; // 输出 100注意当传递引用时你必须确保被引用的对象在线程访问期间一直有效生命周期问题并且要考虑对共享数据的访问需要同步数据竞争问题。传递只能移动的类型比如std::unique_ptr或std::future。这些对象不能被拷贝但可以被移动到线程的内部存储中。std::unique_ptrint ptr std::make_uniqueint(99); // std::thread t([](std::unique_ptrint p){}, ptr); // 错误unique_ptr不可拷贝 std::thread t([](std::unique_ptrint p){ std::cout *p; }, std::move(ptr)); // 正确移动进去 t.join(); // 此时外部的ptr已经是nullptr了理解这些参数传递的细节是写出正确多线程代码的第一步它能帮你避免很多因数据副本或悬空引用导致的诡异bug。3. std::thread成员函数深度解析与实战了解了设计理念我们再来逐个拆解std::thread的成员函数看看它们在实际项目中该怎么用以及有哪些需要特别注意的地方。3.1 构造线程从简单到复杂创建线程最常用的就是传入一个可调用对象和它的参数。可调用对象可以是函数指针、函数对象、Lambda表达式、std::function甚至是成员函数。1. 普通函数和静态成员函数void global_func(int x, const std::string s) { /* ... */ } class MyClass { public: static void static_func(double d) { /* ... */ } }; std::thread t1(global_func, 10, “hello”); std::thread t2(MyClass::static_func, 3.14);2. 非静态成员函数需要传递一个对象实例或指针/引用作为第一个参数。class Worker { public: void do_work(int id) { std::cout “Worker ” id “ is working.\n”; } }; Worker w; // 传递对象指针线程内通过指针调用成员函数 std::thread t(Worker::do_work, w, 1); // 或者传递对象的引用使用std::ref // std::thread t(Worker::do_work, std::ref(w), 1); t.join();这里的关键是你需要确保对象w的生命周期至少覆盖线程t的执行期。如果w被提前销毁了线程再去访问就是未定义行为。3. Lambda表达式最常用简洁直观尤其适合简单的任务。int captured_var 100; std::thread t([captured_var]() { // 按值捕获 std::this_thread::sleep_for(std::chrono::milliseconds(10)); std::cout “Captured: ” captured_var std::endl; }); t.join();使用Lambda时要特别注意捕获变量的方式按值[]、按引用[]、或混合和生命周期。按引用捕获外部局部变量是极其危险的除非你能百分百确定该变量的生命周期。4. 可调用对象仿函数struct Task { int base; Task(int b) : base(b) {} void operator()(int multiplier) const { std::cout “Result: ” base * multiplier std::endl; } }; Task task_obj(5); std::thread t(task_obj, 3); // 会拷贝task_obj一份到线程内部 t.join(); // 或者临时构造 std::thread t(Task(5), 3); // 传递临时对象 t.join();3.2 join()等待与资源回收join()可能是你最常用的成员函数。它的作用很简单阻塞调用它的线程通常是主线程直到被join的线程执行完毕。从线程函数返回后该线程就结束了系统会回收其资源如栈内存。调用join()后std::thread对象变为不可汇合non-joinable状态之后可以安全析构。一个重要的实践模式RAII包装器由于必须保证join()或detach()被调用我们可以利用C的RAII资源获取即初始化特性创建一个包装类在析构函数中自动join。这能有效防止因异常或提前返回而忘记join。class ThreadGuard { std::thread t; public: explicit ThreadGuard(std::thread t_) : t(t_) {} ~ThreadGuard() { if (t.joinable()) { // 必须检查 t.join(); } } // 禁止拷贝和移动确保职责单一 ThreadGuard(const ThreadGuard) delete; ThreadGuard operator(const ThreadGuard) delete; }; void risky_function() { std::thread t([](){ /* 可能抛出异常的任务 */ }); ThreadGuard g(t); // 创建守卫 // ... 这里如果发生异常栈展开时会析构gg会调用t.join() // 或者正常返回析构g时也会join // 我们不需要手动写 t.join(); }这个ThreadGuard在构造函数中接收一个线程的引用在析构函数中检查并join。注意它存储的是引用所以被守护的线程对象t的生命周期必须长于ThreadGuard对象g。更健壮的实现可能会用std::thread的移动语义直接取得所有权。3.3 detach()放飞线程后果自负detach()将std::thread对象与其管理的执行线程分离。分离后该线程会独立地在后台运行常被称为“守护线程”或“后台线程”其资源在线程结束时由系统自动回收。调用detach()后原std::thread对象变为不可汇合状态。什么时候用detach适用于那些“发了就不管”的任务比如日志写入线程。监控或心跳线程。一些一次性的、不关心结果的异步任务。detach的巨大风险失去控制权分离后你无法再通过std::thread对象与该线程交互不能join不能获取id等。生命周期风险你必须确保线程函数内部访问的所有数据尤其是通过引用或指针捕获的数据在其整个执行期间都是有效的。最常见的问题是在函数中detach了一个使用局部变量引用的Lambda线程函数返回后局部变量销毁线程还在访问导致未定义行为。void dangerous_detach() { int local_data 42; std::thread t([local_data]() { // 按引用捕获局部变量大忌 std::this_thread::sleep_for(std::chrono::seconds(1)); std::cout local_data std::endl; // 访问可能已销毁的内存 }); t.detach(); // 分离函数立即返回 } // 函数结束local_data被销毁。但分离的线程1秒后才尝试访问它黄金法则如果你决定detach一个线程请确保它不依赖其创建作用域内的任何自动存储期局部变量。最好让线程函数完全自包含或者通过智能指针如std::shared_ptr来共享堆上数据的所有权。3.4 joinable()、get_id() 和 hardware_concurrency()joinable()这是一个安全检查开关。在调用join()或detach()之前务必先检查。对非joinable的线程调用join()或detach()会抛出std::system_error异常。std::thread t; if (t.joinable()) { // false默认构造的线程对象不可join t.join(); // 不会执行到这里 }get_id()返回一个std::thread::id类型的对象标识线程。如果线程不可汇合如默认构造、已移动、已join/detach则返回一个默认构造的id对象表示“没有线程”。std::thread::id可以比较相等、输出到流也可以作为容器的键例如用于维护线程特定的数据。std::thread t([]{}); std::cout “Main thread ID: ” std::this_thread::get_id() ‘\n’; std::cout “Spawned thread ID: ” t.get_id() ‘\n’; t.join(); std::cout “After join, thread ID: ” t.get_id() ‘\n’; // 输出默认的“没有线程”的idhardware_concurrency()这是一个静态成员函数返回一个提示值表示实现认为的硬件线程上下文数量通常等于CPU核心数如果支持超线程则是核心数的两倍。这个值只是一个提示用于指导你创建合适数量的线程例如用于线程池的大小。它可能返回0如果信息不可用的话。unsigned int num_threads std::thread::hardware_concurrency(); std::cout “Suggested number of threads: ” (num_threads ? num_threads : 2) std::endl; // 通常可以这样设置线程池大小 // size_t pool_size std::max(1u, std::thread::hardware_concurrency());3.5 swap()交换线程句柄swap成员函数和std::swap特化版本用于交换两个std::thread对象所管理的底层线程句柄。这在某些需要重新组织线程管理的场景下有用但日常使用频率不高。std::thread t1(task_a); std::thread t2(task_b); std::cout “t1 ID: ” t1.get_id() “, t2 ID: ” t2.get_id() std::endl; t1.swap(t2); // 或者 std::swap(t1, t2); std::cout “After swap, t1 ID: ” t1.get_id() “, t2 ID: ” t2.get_id() std::endl; // 现在t1管理着原来t2的线程t2管理着原来t1的线程。3.6 native_handle()触及底层实现native_handle()返回一个与平台相关的原生线程句柄。例如在POSIX系统Linux/macOS上是pthread_t在Windows上是HANDLE。除非你有非常特殊的、标准库无法满足的系统级需求比如设置线程的实时调度策略、绑定CPU亲和性等否则绝对不要使用这个函数。使用它会让你的代码立刻失去可移植性。// Linux/POSIX 示例设置线程调度策略和优先级非可移植代码 #include pthread.h #include thread #include iostream #include cstring std::thread t([]{ /* 任务 */ }); pthread_t native_hdl t.native_handle(); sched_param sch; int policy; pthread_getschedparam(native_hdl, policy, sch); sch.sched_priority sched_get_priority_max(SCHED_FIFO); // 设置为最高实时优先级 if (pthread_setschedparam(native_hdl, SCHED_FIFO, sch)) { std::cerr “Failed to set scheduling: ” strerror(errno) std::endl; } t.join();警告使用native_handle()进行的任何操作其行为、线程安全性和资源管理责任都不再由C标准库保证完全由你自己和底层操作系统API负责。请慎之又慎。4. std::this_thread命名空间当前线程的操控台std::this_thread命名空间提供了一组函数用于操作当前正在执行的线程也就是调用这些函数的线程本身。4.1 yield()主动让出时间片std::this_thread::yield()的作用是提示调度器当前线程愿意放弃当前的时间片让其他就绪线程有机会运行。这通常用在“忙等待”或自旋锁的场景中以避免一个线程长时间占用CPU导致其他线程饿死。// 一个简单的自旋锁实现仅作示例实际应用请用std::atomic或std::mutex std::atomicbool lock_flag{false}; void acquire_spinlock() { while (lock_flag.exchange(true, std::memory_order_acquire)) { // 尝试获取锁 // 获取失败锁已被占用 std::this_thread::yield(); // 主动让出CPU减少忙等待的消耗 } } void release_spinlock() { lock_flag.store(false, std::memory_order_release); }在忙等待循环中加入yield()可以显著降低CPU占用率。但要注意yield()只是一个建议操作系统调度器可能不立即切换线程。4.2 sleep_for() 与 sleep_until()让线程休眠这两个函数用于阻塞当前线程一段时间。sleep_for(duration)阻塞当前线程至少指定的时间长度。sleep_until(time_point)阻塞当前线程直到到达指定的时间点。它们常用于模拟耗时操作、定时任务或控制循环频率。// 每100毫秒执行一次任务 while (running) { do_some_work(); std::this_thread::sleep_for(std::chrono::milliseconds(100)); } // 在下一个整点执行 auto now std::chrono::system_clock::now(); auto next_hour std::chrono::ceilstd::chrono::hours(now); // C17 chrono rounding std::this_thread::sleep_until(next_hour); do_something_at_the_hour();重要提示休眠时间可能比指定的要长因为线程调度有开销且可能被更高优先级的线程抢占。所以sleep函数不适合做高精度的实时定时。4.3 get_id()获取当前线程ID与std::thread::get_id()类似但这是获取调用者自身的线程ID。在日志、调试或需要区分不同线程执行的上下文中非常有用。void log_message(const std::string msg) { std::cout “[Thread ” std::this_thread::get_id() “] ” msg std::endl; }5. 实战进阶构建健壮的多线程应用框架掌握了所有零件现在我们来组装一台机器。在实际项目中直接裸用std::thread创建大量线程往往不是最佳实践。我们需要更高级的模式来管理线程的生命周期、任务分配和错误处理。5.1 基础线程池的实现思路线程池的核心思想是预先创建一组线程工作线程它们从一个共享的任务队列中获取并执行任务。这避免了频繁创建和销毁线程的巨大开销。一个最简化的线程池需要以下组件任务队列一个线程安全的队列例如用std::queue配合std::mutex和std::condition_variable实现用于存放待执行的函数或可调用对象。工作线程组一个std::vectorstd::thread存放所有工作线程。停止标志一个布尔标志用于通知所有工作线程优雅退出。核心工作线程循环伪代码void worker_thread(std::atomicbool stop, ThreadSafeQueueTask tasks) { while (!stop) { Task task; if (tasks.try_pop(task)) { // 或使用带超时的wait_and_pop task(); // 执行任务 } else { // 队列为空可以短暂休眠或等待条件变量通知 std::this_thread::yield(); // 或者 std::this_thread::sleep_for(std::chrono::milliseconds(1)); } } // 退出前可以处理队列中剩余的任务可选 }主线程或提交任务的线程将任务push到队列中。工作线程不断尝试从队列中pop任务并执行。当需要停止线程池时将stop标志设为true并通知通过条件变量所有可能阻塞在空队列上的工作线程然后对每个工作线程调用join()。5.2 使用std::async进行简单的异步任务对于简单的“发射后忘记”或需要获取结果的单次异步任务std::async配合std::future可能是比直接使用std::thread更高级、更安全的选择。std::async本质上是一个更易用的任务包装器它内部可能使用线程池取决于启动策略帮你处理了线程创建、返回值传递和异常传播。#include future #include iostream int compute_heavy_task(int x) { std::this_thread::sleep_for(std::chrono::seconds(1)); return x * x; } int main() { // 异步启动任务可能在新线程中执行std::launch::async std::futureint fut std::async(std::launch::async, compute_heavy_task, 10); // 在主线程做其他事情... std::cout “Main thread is doing other work...\n”; // 当需要结果时调用get()这会阻塞直到任务完成 int result fut.get(); // 如果任务中抛出异常get()会重新抛出该异常 std::cout “Result: ” result std::endl; // 输出 100 return 0; }std::async的启动策略std::launch::async保证异步执行在新线程中运行。std::launch::deferred延迟执行直到在返回的future上调用get()或wait()时才在当前线程同步执行。默认策略不指定是std::launch::async | std::launch::deferred由实现决定可能是异步也可能是延迟这带来了不确定性所以生产代码中最好明确指定策略。5.3 线程与异常安全多线程环境下的异常处理需要格外小心。如果一个线程函数中抛出了异常并且没有被该函数内部捕获那么这个异常会传播到线程的顶层导致std::terminate()被调用整个程序终止。最佳实践在线程入口函数的最外层进行try-catch。void thread_entry_point() { try { // 实际的线程工作逻辑 do_real_work(); } catch (const std::exception e) { // 记录日志通知主线程或进行其他恢复操作 std::cerr “Thread crashed: ” e.what() std::endl; // 注意这里不能直接终止程序最好通过某种机制通知主线程 // 例如设置一个共享的错误标志或通过promise/future传递异常 } catch (...) { std::cerr “Thread crashed with unknown exception.” std::endl; } } std::thread t(thread_entry_point);更好的方式是将异常传递回创建线程的上下文。这可以通过std::promise和std::future来实现std::promisevoid promise; std::futurevoid future promise.get_future(); std::thread t([promise] { try { do_risky_work(); promise.set_value(); // 通知成功 } catch (...) { promise.set_exception(std::current_exception()); // 捕获并传递异常 } }); try { future.get(); // 这里会等待并可能重新抛出线程中设置的异常 std::cout “Thread finished successfully.\n”; } catch (const std::exception e) { std::cerr “Thread failed: ” e.what() std::endl; } t.join();6. 避坑指南与性能考量多线程编程是“坑”的代名词。下面是一些我踩过或者见别人踩过的典型坑以及对应的避坑建议。6.1 数据竞争与同步std::thread只负责创建和管理线程不提供任何数据同步机制。当多个线程访问同一块内存且至少有一个是写操作时就会发生数据竞争导致未定义行为。解决方案使用C标准库提供的同步原语如std::mutex互斥锁、std::atomic原子操作、std::condition_variable条件变量等。// 错误示例数据竞争 int shared_counter 0; std::vectorstd::thread threads; for (int i 0; i 10; i) { threads.emplace_back([shared_counter]() { for (int j 0; j 1000; j) { shared_counter; // 多个线程同时读写结果不确定 } }); } for (auto t : threads) t.join(); std::cout “Counter (wrong): ” shared_counter std::endl; // 很可能不是10000 // 正确示例使用互斥锁 std::mutex counter_mutex; int safe_counter 0; std::vectorstd::thread safe_threads; for (int i 0; i 10; i) { safe_threads.emplace_back([safe_counter, counter_mutex]() { for (int j 0; j 1000; j) { std::lock_guardstd::mutex lock(counter_mutex); // RAII锁 safe_counter; } }); } for (auto t : safe_threads) t.join(); std::cout “Counter (correct): ” safe_counter std::endl; // 一定是10000 // 更优方案使用原子操作对于简单计数器性能远高于互斥锁 std::atomicint atomic_counter{0}; std::vectorstd::thread atomic_threads; for (int i 0; i 10; i) { atomic_threads.emplace_back([atomic_counter]() { for (int j 0; j 1000; j) { atomic_counter; // 原子操作线程安全 } }); } for (auto t : atomic_threads) t.join(); std::cout “Counter (atomic): ” atomic_counter std::endl; // 100006.2 死锁当两个或更多线程互相等待对方持有的锁时就会发生死锁所有相关线程都会永久阻塞。常见死锁场景锁顺序不一致线程A先锁M1再锁M2线程B先锁M2再锁M1。在持有锁时调用未知代码该代码可能试图获取另一个锁形成复杂的依赖环。避免死锁的准则固定锁顺序如果多个锁必须同时持有确保所有线程都以相同的全局顺序获取它们。使用std::lock一次性锁定多个互斥量std::lock(m1, m2, ...)可以一次性锁定多个互斥量且能避免因锁顺序导致的死锁。然后使用std::lock_guard配合std::adopt_lock来管理锁的生命周期。std::mutex m1, m2; void safe_operation() { std::lock(m1, m2); // 一次性锁定避免死锁 std::lock_guardstd::mutex lock1(m1, std::adopt_lock); std::lock_guardstd::mutex lock2(m2, std::adopt_lock); // 操作受保护的数据 }避免嵌套锁尽量缩小锁的粒度持有一个锁的时间尽可能短。如果逻辑复杂考虑重构代码。使用std::scoped_lock(C17)它是std::lock_guard的增强版可以直接用于多个互斥量内部使用std::lock来避免死锁。std::mutex m1, m2; void safe_operation_cpp17() { std::scoped_lock lock(m1, m2); // 等价于上面的std::locklock_guard组合 // 操作受保护的数据 }6.3 性能陷阱线程不是越多越好创建线程本身有开销内存、内核对象。线程过多会导致大量的上下文切换反而降低整体性能。通常线程数量与CPU核心数相匹配或略多时效率最高。计算密集型任务线程数最好等于或略少于CPU物理核心数。使用std::thread::hardware_concurrency()作为参考。I/O密集型任务线程数可以多于核心数因为线程在等待I/O如磁盘、网络时会阻塞CPU可以切换到其他线程工作。工具善用性能分析工具如perf, VTune, 各种Profiler来观察你的多线程程序是否存在大量上下文切换、锁竞争Contention或缓存失效Cache Miss这些都是性能瓶颈的信号。6.4 调试多线程程序调试多线程程序是痛苦的因为bug可能时隐时现“海森堡Bug”。一些有用的策略简化与复现尽量构造一个最小的、可稳定复现问题的测试用例。静态分析工具使用如Clang的ThreadSanitizer (TSan)、Helgrind等工具来检测数据竞争和死锁。它们在开发阶段非常有用。日志与断言在关键路径添加详细的日志注意日志输出本身也需要线程安全使用断言检查不变量。谨慎使用断点在调试器中单步执行多线程程序可能会改变线程的时序掩盖竞争条件。有时需要让程序全速运行在可疑代码处打条件断点或使用数据断点。7. 从std::thread到现代C并发std::thread是C并发编程的基石但现代CC11/14/17/20提供了更多高级抽象让并发编程更安全、更高效。std::async/std::future/std::promise用于异步任务和结果/异常传递如前所述。std::packaged_task将任何可调用对象包装成一个可以异步执行并获取其std::future的任务。常用于向线程池提交任务。执行策略C17许多标准库算法如std::sort,std::for_each现在支持并行执行策略std::execution::par可以自动利用多核。#include algorithm #include execution #include vector std::vectorint data {…}; // 并行排序 std::sort(std::execution::par, data.begin(), data.end());协程C20这是并发编程的范式转变。协程允许你以同步的方式编写异步代码极大地简化了复杂的异步逻辑如网络服务器、生成器。虽然std::thread是基于操作系统线程的“重量级”并发协程则是用户态的“轻量级”并发可以创建成千上万个而开销很小。理解std::thread是理解所有这些高级特性的基础。它教你线程的本质、同步的重要性以及资源管理的复杂性。当你扎实掌握了std::thread的方方面面再去看std::async、线程池、协程你会觉得它们都是在解决std::thread直接使用时的各种不便和痛点理解起来也就水到渠成了。多线程编程是一场与不确定性和复杂性的战斗而std::thread就是你手中的第一件也是最重要的一件武器。用好它理解它你才能在并发编程的道路上走得更稳、更远。