罗罗编程学习记录
本页内容 展开查看

04.9.3 多线程与原子操作

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.9 C 与 C++

覆盖范围

  • std::thread 创建与 join/detach
  • mutex 体系:mutex、lock_guard、unique_lock、shared_mutex
  • condition_variable 等待通知机制
  • std::atomic 与 memory_order 六种枚举
  • 无锁编程基础:CAS、ABA 问题、无锁队列

高频题速览

编号 题目 难度 频率
04.9.3-001 std::thread 创建与 join/detach 基础 ★★★★★
04.9.3-002 mutex 与 lock_guard 用法 基础 ★★★★★
04.9.3-003 condition_variable 怎么用 进阶 ★★★★☆
04.9.3-004 memory_order 六种枚举的区别 高级 ★★★★☆
04.9.3-005 什么是 CAS,ABA 问题怎么解决 高级 ★★★★☆
04.9.3-006 死锁产生的四个必要条件 基础 ★★★★★
04.9.3-007 atomic 比锁快在哪里 进阶 ★★★★☆
04.9.3-008 unique_lock 和 lock_guard 的区别 进阶 ★★★★☆

04.9.3-001 std::thread 怎么创建线程?join 和 detach 有什么区别?

频率 ★★★★★ | 难度 基础

一句话结论

std::thread 构造时传入函数或可调用对象就启动线程;join() 阻塞等待线程结束并回收资源,detach() 让线程后台运行、不再和 thread 对象关联;thread 对象析构前必须 join 或 detach,否则程序终止。

概念解释

  • std::thread 是 C++11 的线程库,封装了操作系统线程。
  • join():主线程阻塞,直到子线程执行完毕,然后回收线程资源。
  • detach():分离线程,子线程在后台运行,thread 对象和它脱钩,主线程不再等它。
  • 可 join 状态:thread 对象刚创建时是可 join 的;join 或 detach 之后变成不可 join。

原理流程

  1. thread t(func) 构造时,操作系统创建一个新线程,开始执行 func。
  2. 如果在 thread 对象析构前既没有 join 也没有 detach,析构函数会调用 std::terminate() 终止程序。
  3. join() 是阻塞调用,调用线程会一直等到目标线程结束。
  4. detach() 之后,目标线程变成守护线程,主线程退出时它也会被强制终止。

代码 / 示例

#include <thread>
#include <iostream>

void worker(int id) {
    std::cout << "线程 " << id << " 开始工作" << std::endl;
    // ... 做事情
    std::cout << "线程 " << id << " 结束" << std::endl;
}

int main() {
    // 创建线程,传入函数和参数
    std::thread t1(worker, 1);
    std::thread t2(worker, 2);

    // 等待两个线程结束
    t1.join();
    t2.join();

    // detach 的用法:后台任务
    std::thread t3([]{
        // 后台跑日志清理
    }).detach(); // 立刻 detach,不再管它

    // 注意:detach 之后不能再用 t3 操作这个线程
    return 0;
}

常见误区

  • 误区:thread 析构会自动等待线程结束?正解:不会。如果析构时线程还在 joinable,程序直接 terminate。
  • 误区:detach 后线程就安全了?正解:detach 的线程访问局部变量或悬垂引用会出问题,因为主线程可能已经退出,栈帧都销毁了。

追问 / 延伸

  • 怎么等待多个线程但不按顺序?答:用 join,join 本身就是阻塞的;或者用 condition_variable 做事件通知。
  • thread 可以拷贝吗?答:不能拷贝,只能移动(std::move)。

04.9.3-002 mutex 怎么用?lock_guard 解决什么问题?

频率 ★★★★★ | 难度 基础

一句话结论

mutex 是互斥锁,同一时间只允许一个线程持有;lock_guard 是 RAII 封装,构造时自动 lock,析构时自动 unlock,防止异常时忘记 unlock。

概念解释

  • std::mutex:最基本的互斥锁,lock() 阻塞获取,unlock() 释放。
  • std::lock_guard:栈对象,构造时 lock,析构时 unlock,作用域结束自动释放。
  • 手动 lock/unlock 的问题:异常时 unlock 没执行到,锁永远不释放。

原理流程

  1. 多个线程同时访问共享数据,需要用 mutex 保护临界区。
  2. lock_guard 构造时调用 mutex.lock(),如果锁被别人持有就阻塞等待。
  3. 离开作用域时(不管正常结束还是异常展开),lock_guard 析构自动调用 mutex.unlock()。
  4. 这就是 RAII 在多线程中的应用。

代码 / 示例

#include <mutex>
#include <vector>

std::mutex mtx;
std::vector<int> shared_data;

void add_data(int x) {
    std::lock_guard<std::mutex> lock(mtx); // 构造时 lock
    shared_data.push_back(x);
} // 离开作用域,lock_guard 析构,自动 unlock

// 手动方式的问题:
void bad_add(int x) {
    mtx.lock();
    if (x < 0) {
        throw std::runtime_error("invalid");
        // mtx.unlock() 没执行到,锁永远不释放
    }
    shared_data.push_back(x);
    mtx.unlock();
}

常见误区

  • 误区:lock_guard 可以中途 unlock?正解:不行,lock_guard 一旦构造就管到作用域结束,不能提前释放;需要中途释放用 unique_lock。
  • 误区:锁的粒度越细越好?正解:太细的锁会增加加锁解锁开销,太粗会降低并发度,需要根据实际场景权衡。

追问 / 延伸

  • recursive_mutex 是什么?答:递归互斥锁,同一个线程可以多次 lock,不会死锁,适合递归函数或同一类的多个方法互相调用。
  • try_lock 是什么?答:非阻塞尝试加锁,拿到锁返回 true,没拿到返回 false,不阻塞。

04.9.3-003 condition_variable 怎么用?解决什么问题?

频率 ★★★★☆ | 难度 进阶

一句话结论

condition_variable 是线程间的等待通知机制:线程 A 在条件不满足时 wait() 挂起,线程 B 完成操作后 notify_one()/notify_all() 唤醒等待的线程,避免轮询浪费 CPU。

概念解释

  • condition_variable 必须配合 unique_lock 使用。
  • wait():释放 mutex 并挂起当前线程,直到被 notify 唤醒。
  • notify_one():唤醒一个等待的线程。
  • notify_all():唤醒所有等待的线程。
  • 虚假唤醒:被唤醒时条件可能还是不满足,所以 wait 要放在 while 循环里检查条件。

原理流程

  1. 生产者:加锁 → 放数据 → notify_one() → 解锁。
  2. 消费者:加锁 → while(队列空) wait() → 取数据 → 解锁。
  3. wait() 内部做两件事:释放 mutex,挂起线程。
  4. 被 notify 唤醒时,wait() 会重新获取 mutex,然后返回。
  5. 因为可能有虚假唤醒,唤醒后必须再检查一次条件,条件不满足就继续 wait。

代码 / 示例

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

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

void producer() {
    for (int i = 0; i < 10; i++) {
        {
            std::lock_guard<std::mutex> lock(mtx);
            queue.push(i);
        }
        cv.notify_one(); // 通知消费者
    }
}

void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        // 必须用 while,不能用 if,防止虚假唤醒
        while (queue.empty()) {
            cv.wait(lock); // 释放锁并挂起,被唤醒后重新加锁
        }
        int x = queue.front();
        queue.pop();
        lock.unlock(); // 取完数据手动解锁

        // 处理 x...
        if (x == 9) break;
    }
}

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

常见误区

  • 误区:wait 可以用 if 判断?正解:必须用 while,因为可能有虚假唤醒(被唤醒但条件还是不满足),或者多个消费者被唤醒时只有一个能拿到数据。
  • 误区:notify 之前必须加锁?正解:不需要,但加锁也没问题;notify 的作用是唤醒等待的线程,不需要持有锁。

追问 / 延伸

  • 什么是虚假唤醒?答:操作系统或库实现中,线程可能在没有被 notify 的情况下被唤醒,原因是信号或其他内部机制;标准库规定这种情况可能发生,所以代码必须能处理。
  • condition_variable_any 是什么?答:可以配合任何锁类型,不限于 unique_lock,但性能略差。

04.9.3-004 memory_order 的六种枚举分别是什么?

频率 ★★★★☆ | 难度 高级

一句话结论

memory_order 控制原子操作的内存可见性和重排约束:relaxed 只保证原子性不保证顺序;release/acquire 保证写之前的操作不会排到后面、读之后的操作不会排到前面;acq_rel 是两者的结合;seq_cst 是最强的顺序一致性。

概念解释

  • memory_order_relaxed:只保证这个操作本身是原子的,不约束其他操作的重排。
  • memory_order_release:写操作,之前的所有读写都不会重排到这个操作之后。
  • memory_order_acquire:读操作,之后的所有读写都不会重排到这个操作之前。
  • memory_order_acq_rel:读写操作,同时有 acquire 和 release 的语义。
  • memory_order_seq_cst:顺序一致性,所有线程看到的操作顺序都一致,是最强的保证,也是默认值。

原理流程

  1. 编译器和 CPU 为了性能会对指令重排:只要单线程下语义不变,就可能调整顺序。
  2. 在多线程下,重排会导致一个线程写的东西,另一个线程看不到或看到的顺序不对。
  3. memory_order_release 相当于写操作前面插了一道屏障,前面的操作不能排到后面。
  4. memory_order_acquire 相当于读操作后面插了一道屏障,后面的操作不能排到前面。
  5. release 和 acquire 配对使用:release 线程写之前的所有东西,acquire 线程读之后都能看到。

代码 / 示例

#include <atomic>
#include <thread>
#include <cassert>

std::atomic<bool> ready{false};
int data = 0;

void producer() {
    data = 42; // 普通写
    ready.store(true, std::memory_order_release); // release
}

void consumer() {
    while (!ready.load(std::memory_order_acquire)) {} // acquire
    assert(data == 42); // 一定成立,因为 release/acquire 配对
}

// relaxed 的例子:计数器,只需要原子,不需要顺序
std::atomic<int> count{0};
void increment() {
    count.fetch_add(1, std::memory_order_relaxed); // 只是原子加,不约束其他顺序
}

常见误区

  • 误区:所有 atomic 操作都用 seq_cst 最安全?正解:seq_cst 性能开销最大,因为要做全局顺序约束;性能敏感的场景用 release/acquire 或 relaxed。
  • 误区:relaxed 就没用了?正解:像计数器这种只需要原子性、不需要顺序约束的场景,relaxed 性能最好。

追问 / 延伸

  • 什么是顺序一致性?答:所有线程看到的所有操作的顺序都和程序顺序一致,就像全局有一把锁,操作一个一个执行。
  • release 和 acquire 为什么要配对?答:release 是写端,acquire 是读端,两者配对才能形成"写端之前的操作,读端都能看到"的保证。

04.9.3-005 什么是 CAS?ABA 问题怎么解决?

频率 ★★★★☆ | 难度 高级

一句话结论

CAS(Compare-And-Swap)是原子操作:比较内存地址的值是否等于预期值,如果相等就换成新值,整个过程是原子的;ABA 问题是指值从 A 变成 B 又变回 A,CAS 以为没变过,实际上中间变过了,解决方法是加版本号。

概念解释

  • CAS 三个操作数:内存地址、预期值、新值。
  • 如果内存地址的值等于预期值,就原子地把它改成新值,返回 true;否则什么都不做,返回 false。
  • std::atomic::compare_exchange_weak/strong 就是 CAS 的封装。
  • ABA 问题:线程 1 读到值是 A,线程 2 把 A 改成 B 又改回 A,线程 1 的 CAS 发现值还是 A,以为没变过,实际上中间变过了。

原理流程

  1. 无锁队列的出队操作:读头指针 head,构造新节点。
  2. 用 CAS 把 head 从 old_head 改成 new_head。
  3. 如果 CAS 成功,出队完成;如果失败,说明其他线程也在操作,重试。
  4. ABA 问题:头指针从 A 变成 B 又变回 A,CAS 成功了,但中间队列结构已经变了,可能导致指针指向错误的节点。

代码 / 示例

#include <atomic>

std::atomic<int> value{0};

void cas_demo() {
    int expected = 0;
    int desired = 42;
    // CAS:如果 value == expected,就改成 desired
    bool success = value.compare_exchange_strong(expected, desired);
    // 如果失败,expected 会被更新为当前 value 的值
}

// ABA 问题示例
std::atomic<int> aba_counter{100};

void thread1() {
    int expected = 100;
    // 假设线程 2 把 100 改成 200 又改回 100
    bool success = aba_counter.compare_exchange_strong(expected, 300);
    // CAS 成功了,但中间值变过,业务逻辑可能不允许
}

// 解决 ABA:加版本号
struct VersionedPointer {
    void* ptr;
    uint64_t version;
};
std::atomic<VersionedPointer> head;

// 每次 CAS 时,不仅比较指针,也比较版本号
// 版本号每次修改都 +1,即使指针值变了又变回来,版本号也不一样

常见误区

  • 误区:CAS 不会失败?正解:多线程并发时 CAS 可能失败,需要重试(自旋)。
  • 误区:ABA 问题只在理论上存在?正解:在无锁数据结构中,ABA 可能导致节点被错误释放,产生内存错误。

追问 / 延伸

  • compare_exchange_weak 和 strong 有什么区别?答:weak 允许伪失败(值相等但返回 false),在循环中性能更好;strong 不会伪失败。
  • 怎么解决 ABA?答: tagged pointer(指针 + 版本号),或者用 hazard pointer、epoch-based reclamation。

04.9.3-006 死锁产生的四个必要条件是什么?怎么避免?

频率 ★★★★★ | 难度 基础

一句话结论

死锁产生的四个必要条件:互斥、持有并等待、不可剥夺、循环等待;破坏任意一个条件就能避免死锁,最常用的方法是按固定顺序加锁,破坏循环等待。

概念解释

  • 互斥:资源同一时间只能被一个线程持有。
  • 持有并等待:线程已经持有了一些资源,又在等待其他线程持有的资源。
  • 不可剥夺:资源只能被持有它的线程主动释放,不能被强行抢走。
  • 循环等待:线程之间形成环形等待,A 等 B 持有的资源,B 等 C 持有的资源,C 等 A 持有的资源。

原理流程

  1. 线程 A 持有锁 1,线程 B 持有锁 2。
  2. 线程 A 等锁 2,线程 B 等锁 1。
  3. 两个线程都不释放自己持有的锁,都在等对方的锁。
  4. 循环等待形成,死锁。

代码 / 示例

std::mutex mtx1, mtx2;

// 死锁写法:线程 1 先锁 1 再锁 2,线程 2 先锁 2 再锁 1
void thread1() {
    std::lock_guard<std::mutex> l1(mtx1);
    std::lock_guard<std::mutex> l2(mtx2); // 等 mtx2
}

void thread2() {
    std::lock_guard<std::mutex> l2(mtx2);
    std::lock_guard<std::mutex> l1(mtx1); // 等 mtx1
}

// 正确写法:所有线程都按相同顺序加锁
void thread1_fixed() {
    std::lock_guard<std::mutex> l1(mtx1); // 先锁小地址的
    std::lock_guard<std::mutex> l2(mtx2); // 再锁大地址的
}

void thread2_fixed() {
    std::lock_guard<std::mutex> l1(mtx1); // 也是先锁 mtx1
    std::lock_guard<std::mutex> l2(mtx2); // 再锁 mtx2
}

// 或者用 std::lock 一次性锁多个,不会死锁
void thread_safe() {
    std::unique_lock<std::mutex> l1(mtx1, std::defer_lock);
    std::unique_lock<std::mutex> l2(mtx2, std::defer_lock);
    std::lock(l1, l2); // 内部按地址排序加锁,不会死锁
}

常见误区

  • 误区:死锁只在多线程加锁时发生?正解:任何资源(文件句柄、数据库连接、信号量)只要满足四个条件都可能死锁。
  • 误区:加锁顺序只要一致就永远不会死锁?正解:如果只看两个锁是这样,但如果锁很多、嵌套很深,很难保证全局顺序一致。

追问 / 延伸

  • 怎么检测死锁?答:用 ThreadSanitizer(-fsanitize=thread)可以在开发阶段检测死锁和数据竞争。
  • try_lock 怎么用来避免死锁?答:尝试加锁,失败就释放所有锁,等一会再重试,破坏"持有并等待"条件。

04.9.3-007 atomic 比互斥锁快在哪里?

频率 ★★★★☆ | 难度 进阶

一句话结论

atomic 是无锁操作,不需要操作系统调度,用户态就能完成;mutex 是内核态同步,阻塞时线程会被挂起,唤醒需要上下文切换,开销大几个数量级。

概念解释

  • atomic:CPU 提供的原子指令(如 xchg、cmpxchg),在硬件层面保证操作不可分,不需要进入内核。
  • mutex:用户态 + 内核态混合,没竞争时走用户态快速路径,有竞争时内核把线程挂起,需要上下文切换。
  • 原子操作适合简单的计数器、标志位;复杂的临界区还是用 mutex。

原理流程

  1. 无竞争时:mutex 的快速路径也是用户态 CAS,和 atomic 差不多快。
  2. 有竞争时:mutex 发现锁被别人持有,调用内核 API 把当前线程挂到等待队列,切到别的线程跑。
  3. 锁释放时,内核唤醒等待队列中的线程,需要上下文切换。
  4. 上下文切换开销是微秒级,atomic 是纳秒级,差 1000 倍以上。

代码 / 示例

#include <atomic>
#include <mutex>

// 计数器:用 atomic
std::atomic<int> atomic_counter{0};
void inc_atomic() {
    atomic_counter++; // 一条原子指令,纳秒级
}

// 计数器:用 mutex
std::mutex mtx;
int mutex_counter = 0;
void inc_mutex() {
    std::lock_guard<std::mutex> lock(mtx); // 无竞争时快,有竞争时慢
    mutex_counter++;
}

// 什么时候用 atomic,什么时候用 mutex?
// - 一个变量的读写:用 atomic
// - 多个变量的一致性:用 mutex
// - 复杂逻辑的临界区:用 mutex

常见误区

  • 误区:atomic 一定比 mutex 快?正解:无竞争时两者差不多;有竞争时 atomic 是自旋重试,太频繁也会浪费 CPU,这时 mutex 挂起更高效。
  • 误区:atomic 可以替代 mutex 保护所有共享数据?正解:atomic 只能保证单个变量的原子性,多个变量的一致性还是要 mutex。

追问 / 延伸

  • 什么是自旋锁?答:用 atomic 实现的锁,获取不到就空转(自旋),适合锁持有时间极短的场景,避免上下文切换开销。
  • 无锁编程的适用场景?答:数据结构简单、临界区极小、并发度极高的场景,比如队列、计数器。

04.9.3-008 unique_lock 和 lock_guard 有什么区别?

频率 ★★★★☆ | 难度 进阶

一句话结论

lock_guard 是简单的 RAII 锁,构造时 lock、析构时 unlock,不能提前释放;unique_lock 更灵活,可以 defer_lock、try_lock、中途 unlock、移动所有权,还能配合 condition_variable 使用。

概念解释

  • lock_guard:最轻量,只有 lock/unlock 两个时机,不能中途释放,不能移动。
  • unique_lock:功能完整,支持:
    • defer_lock:构造时不加锁,后面手动 lock。
    • try_to_lock:尝试加锁,拿不到不阻塞。
    • adopt_lock:已经持有锁,交给 unique_lock 管理。
    • 中途 unlock():不需要等到作用域结束。
    • 移动所有权:可以把锁的所有权转移给另一个 unique_lock。
  • condition_variable 的 wait 要求传入 unique_lock,因为 wait 内部需要释放锁再重新加锁。

原理流程

  1. lock_guard 就是一个简单的 RAII 包装,内部调用 lock 和 unlock,没有其他状态。
  2. unique_lock 内部有一个标志位,表示当前是否持有锁,支持手动 lock/unlock。
  3. condition_variable::wait 需要在等待时释放 mutex,被唤醒时重新获取 mutex——只有 unique_lock 支持这种"中途释放再重新获取"的操作。

代码 / 示例

#include <mutex>
#include <condition_variable>

std::mutex mtx;

// lock_guard:简单场景
void simple_lock() {
    std::lock_guard<std::mutex> lock(mtx);
    // 临界区...
} // 自动 unlock

// unique_lock:需要中途释放
void flexible_lock() {
    std::unique_lock<std::mutex> lock(mtx);
    // 做一些需要锁的操作
    lock.unlock(); // 中途释放,后面不需要锁了
    // 做一些不需要锁的耗时操作
    lock.lock(); // 重新加锁
    // 再做一些需要锁的操作
} // 析构时如果还持有锁,自动 unlock

// unique_lock 配合 condition_variable
std::condition_variable cv;
void wait_demo() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock); // wait 内部会 unlock 并挂起,被唤醒后重新 lock
}

常见误区

  • 误区:unique_lock 一定比 lock_guard 慢?正解:unique_lock 确实多了一些状态字段,但在无竞争场景下性能差异很小;只有极致性能场景才需要在意。
  • 误区:unique_lock 可以随便 unlock 之后就不用管了?正解:unlock 之后 unique_lock 还在,析构时会检查是否持有锁,没持有就不会重复 unlock。

追问 / 延伸

  • shared_mutex 是什么?答:读写锁,多个读线程可以同时持有,写线程独占,C++17 引入。
  • shared_lock 是什么?答:配合 shared_mutex 的 RAII 锁,读锁用。

待整理清单

  • [ ] ThreadSanitizer 使用详解
  • [ ] 无锁队列完整实现
  • [ ] future/promise 与 async 异步任务
  • [ ] C++20 信号量与 latch/barrier