C++ 多线程编程基础：线程管理与同步机制

2.2 生命周期管理：join() vs detach()

2.2.1 核心规则

std::thread 不会自动等待子线程完成，thread 对象销毁时若线程仍处于 joinable 状态（未调用 join/detach），会触发 std::terminate() 终止整个程序。必须通过 join() 或 detach() 主动管理，让 thread 对象变为 non-joinable 状态；核心结论：thread 对象销毁时线程仍运行 → 程序必崩溃。

2.2.2 join() 详解

描述：join() 方法让调用它的线程（通常是主线程）等待，直到被调用 join() 的线程完成其任务。这对于确保某些操作在特定线程完成后才进行非常有用。 使用场景：当你需要确保某个线程的任务在继续执行之前已经完成时使用。 注意事项：调用 join() 的线程必须处于可加入状态，即它不能已经被加入或分离。每个线程只能被加入一次。

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

void thread_function(int id) {
    std::cout << "Thread " << id << " is running\n";
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟工作
    std::cout << "Thread " << id << " has finished\n";
}

int main() {
    std::thread t1(thread_function, 1);
    t1.join(); // 等待 t1 线程结束
    std::cout << "Back in main()\n";
    // main() 函数会等待 t1 线程完成它的任务后才会继续执行。
    return 0;
}

在这个例子中，主线程会等待 t1 线程完成它的任务后才会继续执行，因此输出顺序将是：Thread 1 is running, 等待两秒，Thread 1 has finished, 最后是 Back in main()。

2.2.3 detach() 详解

描述：detach() 方法使得一个线程独立运行，不再与创建它的线程关联。这意味着主线程不会等待被分离的线程完成。 使用场景：当你希望一个线程在后台独立运行，并且不需要等待它完成时使用。 注意事项：一旦调用了 detach()，你将失去对线程的直接控制，无法通过 join() 来等待它的完成。如果程序结束而线程仍在运行，则该线程可能会被强制终止，因此需谨慎处理资源释放等问题。

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

void detached_thread_function(int id) {
    std::cout << "Detached Thread " << id << " is running\n";
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟工作
    std::cout << "Detached Thread " << id << " has finished\n";
}

int main() {
    std::thread t2(detached_thread_function, 2);
    t2.detach(); // 让 t2 线程独立运行
    std::cout << "Back in main(), t2 is detached and running in background\n";
    // 主线程不会等待 t2 线程结束
    std::this_thread::sleep_for(chrono::seconds(3)); // 给 t2 一些时间来完成
    std::cout << "Main thread ends\n";
    return 0;
}

在这个例子中，t2 线程被分离并在后台独立运行。主线程不会等待 t2 线程结束，而是立即继续执行。为了确保 t2 线程有足够的时间完成其任务，在主线程结束前让它睡眠了三秒钟。输出顺序可能是：Detached Thread 2 is running, Back in main(), t2 is detached and running in background, 再等待一段时间后显示 Detached Thread 2 has finished, 最后是 Main thread ends。注意，由于 t2 是分离的，如果主线程提前结束，可能看不到 Detached Thread 2 has finished 的输出。

2.2.4 join() vs detach() 对比表

2.3 参数传递规则

核心原则

参数生存期必须长于访问它的所有线程（detach() 场景需重点注意）；detach() 本身不导致崩溃，核心问题是子线程访问已释放的栈资源；优先用 join()+ 原子标志位 实现优雅退出，减少 detach() 使用。

三、线程状态与同步核心概念

3.1 线程生命周期状态

3.2 多线程竞争与同步核心概念

虚假唤醒：当线程从等待已发出信号的条件变量中醒来，却发现它等待的条件未得到满足时，就会发生虚假唤醒。发生虚假唤醒通常是因为在发出条件变量信号和等待线程最终运行之间，另一个线程运行并更改了条件，导致 wait 的线程被唤醒后，实际条件却未满足。比如我们在 notify_all() 时多个线程都被唤醒，但此时实际共享区却只有少数几个线程可以操作，这时就会造成其他线程被虚假唤醒，可以在 wait 唤醒后再次进行检测 condition 解决虚假唤醒。

解决办法：在条件变量阻塞的代码处增加一个 while 循环，如果被唤醒就要检查一下条件是否符合，如果不符合则要再次进入阻塞等待。这样既避免了忙等待，又避免了虚假唤醒问题。

std::unique_lock<std::mutex> lock(mtx); // 创建 unique_lock 并加锁
// 使用 while 循环确保即使发生虚假唤醒也能正确处理
while (!ready) {
    cv.wait(lock); // 如果条件未满足，则解锁 mtx 并等待通知
}
// 当前线程被唤醒后重新检查条件
if (ready) {
    std::cout << "Worker thread is processing..." << std::endl;
} else {
    std::cout << "Unexpected wake-up!" << std::endl;
}

条件变量：在 C 语言中使用 pthread_cond_wait 函数作为条件变量。在 C++11 以后，可以使用 condition_variable 实现多个线程间的同步，头文件是 #include <condition_variable>。

条件变量主要包括两个动作：一个线程因等待条件变量的条件成立而挂起；另外一个线程使条件成立从而给出唤醒线程的信号，从而唤醒被等待的线程；

为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起；通常情况下这个锁是 std::mutex，并且管理这个锁只能是 std::unique_lock<std::mutex> 等 RAII 模板类。分别是使用以下两个方法实现：等待条件成立使用的是 condition_variable 类成员 wait、wait_for 或 wait_until。唤醒信号使用的是 condition_variable 类成员 notify_one 或者 notify_all 函数。

condition_variable 支持的函数如下: 构造函数: 它只有默认构造函数，拷贝构造函数和赋值符号重载均被禁止 condition_variable(const condition_variable&) = delete;，operator= [delete]；

wait: wait 目前支持 wait，wait_for，wait_until 等三种操作，分别对应不同的场景:

wait： 初始检查：首先调用谓词 pred 检查条件是否满足。如果条件满足，则直接返回，不阻塞线程。 解锁并等待：如果条件不满足，则解锁互斥量并使当前线程进入等待状态。 唤醒并重新检查：当线程被唤醒时，它会重新获取互斥量的锁，并再次调用谓词 pred 检查条件是否满足。如果条件仍然不满足，则继续等待；如果条件满足，则退出 wait 并继续执行后续代码。

template<class Predicate>
void wait(std::unique_lock<std::mutex>& lck, Predicate pred);
// lck：一个已加锁的 std::unique_lock<std::mutex> 对象。
// pred：一个返回布尔值的谓词函数或可调用对象，用于检查等待的条件是否满足。

wait_for：初始检查调用谓词：调用提供的谓词函数 pred 来检查条件是否已经满足。直接返回：如果谓词返回 true，表示条件已经满足，wait_for 直接返回 true，不进行任何等待操作。解锁并等待解锁互斥量：如果谓词返回 false，表示条件尚未满足，wait_for 会自动解锁互斥量 lck 并使当前线程进入等待状态。设置定时器：开始计时，等待指定的相对时间段 rel_time（如 100ms）。阻塞线程：线程在此期间阻塞，直到以下情况之一发生：

• 收到通知：其他线程通过 notify_one() 或 notify_all() 发出通知。
• 超时：指定的等待时间到达。唤醒并重新检查重新获取锁：当线程被唤醒后，它会尝试重新获取互斥量 lck 的锁。再次调用谓词：一旦重新获取了锁，wait_for 会再次调用谓词 pred 检查条件是否满足。条件满足：如果谓词返回 true，则 wait_for 返回 true，线程继续执行后续代码。条件不满足：如果是因为超时导致的唤醒，则 wait_for 返回 false。如果是因为通知导致的唤醒但条件仍不满足，则线程将继续等待（根据具体实现和上下文，可能需要再次调用 wait_for 或者处理其他逻辑）

template<class Rep, class Period, class Predicate>
bool wait_for(
    std::unique_lock<std::mutex>& lock,
    const std::chrono::duration<Rep, Period>& rel_time,
    Predicate stop_waiting);

wait_for 和 wait_until 对比 wait_for：接受一个相对时间段，它定义了线程愿意等待的最大时长。 wait_until：接受一个绝对时间点，它定义了线程应该停止等待的具体时刻。

template<class Predicate>
bool wait_until(std::unique_lock<std::mutex>& lock,
                const std::chrono::time_point<Clock, Duration>& timeout_time,
                Predicate pred);

#include <iostream>
#include <atomic>
#include <condition_variable>
#include <thread>
#include <chrono>

using namespace std::chrono_literals;

std::condition_variable cv;
std::mutex cv_m;
int i;

void waits(int idx) {
    std::unique_lock<std::mutex> lk(cv_m);
    if (cv.wait_for(lk, idx * 100ms, [] { return i == 1; })) {
        std::cerr << "Thread " << idx << " finished waiting. i == " << i << '\n';
    } else {
        std::cerr << "Thread " << idx << " timed out." << '\n';
    }
}