C++高频知识点（十八）

86. C++多线程中，锁的实现方式有哪些？

1. 互斥锁（Mutex）

互斥锁（std::mutex）是最常见的同步机制，用于保护临界区，使得同一时刻只有一个线程可以访问共享资源。

#include <iostream>
#include <thread>
#include <mutex>std::mutex mtx;void print_safe(const std::string& msg) {std::lock_guard<std::mutex> guard(mtx); // 自动加锁和解锁std::cout << msg << std::endl;
}int main() {std::thread t1(print_safe, "Hello from thread 1");std::thread t2(print_safe, "Hello from thread 2");t1.join();t2.join();return 0;
}

• std::lock_guard：常用于在作用域范围内自动管理锁，确保即使发生异常，锁也会被正确释放。

2. 递归互斥锁（Recursive Mutex）

递归互斥锁（std::recursive_mutex）允许同一个线程多次获得同一把锁，而不会引起死锁。适用于递归函数或需要多次加锁的场景。

#include <iostream>
#include <thread>
#include <mutex>std::recursive_mutex rec_mtx;void recursive_function(int n) {if (n <= 0) return;std::lock_guard<std::recursive_mutex> guard(rec_mtx);std::cout << "Recursion depth: " << n << std::endl;recursive_function(n - 1);
}int main() {std::thread t1(recursive_function, 5);t1.join();return 0;
}

3. 读写锁（Shared Mutex）

读写锁（std::shared_mutex in C++17）允许多个线程同时读取数据，但在写数据时，只有一个线程可以获得写锁。适用于读操作频繁、写操作较少的场景。

#include <iostream>
#include <thread>
#include <shared_mutex>
#include <mutex>std::shared_mutex rw_mtx;
int shared_data = 0;void read_data() {std::shared_lock<std::shared_mutex> lock(rw_mtx);std::cout << "Reading data: " << shared_data << std::endl;
}void write_data(int value) {std::unique_lock<std::shared_mutex> lock(rw_mtx);shared_data = value;std::cout << "Writing data: " << shared_data << std::endl;
}int main() {std::thread t1(read_data);std::thread t2(write_data, 42);t1.join();t2.join();return 0;
}

4. 自旋锁（Spinlock）

自旋锁是一种忙等待的锁实现，线程在等待锁的过程中会不断检查锁的状态，而不是进入休眠。适用于锁等待时间非常短的场景。

#include <atomic>
#include <thread>class Spinlock {std::atomic_flag flag = ATOMIC_FLAG_INIT;public:
/*
atomic_flag.test_and_set(acquire)：把标志设为 true，返回设之前的值。
返回 false → 说明之前没人持锁 → 你拿到锁。
返回 true → 已经有人持锁 → 你就在 while 里原地打转（自旋）等别人放锁。
atomic_flag.clear(release)：把标志清为 false，表示释放锁。
*/void lock() {// 返回true就一直转圈等// Acquire（获取）：我看见门开了才进去拿资料。// ⇒ 我进门这刻（acquire）之后要读的东西，不允许被提前到进门之前去读；进去后能看见别人关门前放好的资料。// test_and_set(acquire)：确保拿到锁后再读写共享数据，后续读写不会被提前到拿锁之前。while (flag.test_and_set(std::memory_order_acquire)) {// 自旋等待，什么也不做}}void unlock() {// 放锁// Release（释放）：我把活儿干完、把资料都装进箱子，再把“门”关上发出通知。// ⇒ 门关上这刻（release）之前我做的所有修改，都必须先完成，不能被拖到门关之后。// clear(release)：确保临界区里对共享数据的修改，在清锁之前完成并对外可见。flag.clear(std::memory_order_release);}
};Spinlock spinlock;void critical_section() {spinlock.lock();// 访问共享资源spinlock.unlock();
}int main() {std::thread t1(critical_section);std::thread t2(critical_section);t1.join();t2.join();return 0;
}

#include <atomic>
#include <thread>
#include <iostream>
#include <chrono>// 把下面这个宏改成 1 可以切到 relaxed 版本做对比
// USE_RELAXED=0（默认）：ready.store(..., memory_order_release) + ready.load(..., memory_order_acquire)
// ——正确的发布/获取配对。// USE_RELAXED=1：把两边都改成 memory_order_relaxed
// ——没有跨线程的可见性保证。
#ifndef USE_RELAXED
#define USE_RELAXED 0
#endifint data = 0;                 // 普通共享数据（非原子）
std::atomic<bool> ready{false}; // 原子标志：告诉对方“数据准备好了”void producer() {data = 42; // 普通写：把共享数据准备好#if USE_RELAXED// 没有发布语义：可能发生重排，消费者即便看到 ready=true，也未必能看到 data=42ready.store(true, std::memory_order_relaxed);
#else// 发布（release）：保证 data 的写先于 ready=true 对外可见// 发布：把之前对 data 的写先“封口发布”ready.store(true, std::memory_order_release);
#endif
}int consumer(int& seen) {
#if USE_RELAXEDwhile (!ready.load(std::memory_order_relaxed)) {// 自旋等待std::this_thread::yield();}
#else// 获取（acquire）：保证看到 ready=true 后，再读 data 时能看到发布方的修改while (!ready.load(std::memory_order_acquire)) {// std::this_thread::yield(); 是 C++11 提供的线程调度提示（在 <thread> 里）。作用是：把当前线程剩余的时间片“让出来”，告诉操作系统调度器“我现在没啥可做了，可以先让别的就绪线程跑一会儿”。函数返回 void，不抛异常。std::this_thread::yield();          // 让出时间片，避免满负荷空转}
#endifint x = data;   // 普通读seen = x;return x == 42 ? 0 : 1; // 返回是否出错
}int main() {// 跑多轮，观察是否有不一致const int rounds = 100000;  // 可按机器性能调整int failures = 0;for (int i = 0; i < rounds; ++i) {// 每轮复位data = 0;ready.store(false, std::memory_order_relaxed);int seen = -1;std::thread tC([&]{ failures += consumer(seen); });std::thread tP(producer);tP.join();tC.join();// 可选：偶尔打印下现场（避免刷屏）if (i % 25000 == 0) {
#if USE_RELAXEDstd::cout << "[relaxed] round " << i << ", seen=" << seen << "\n";
#elsestd::cout << "[acq/rel] round " << i << ", seen=" << seen << "\n";
#endif}}#if USE_RELAXEDstd::cout << "[relaxed] failures = " << failures<< " / " << rounds << " (未必容易复现，但理论上可能出错)\n";
#elsestd::cout << "[acquire/release] failures = " << failures<< " / " << rounds << " (应始终为 0)\n";
#endifreturn 0;
}

5. 条件变量（Condition Variable）

条件变量（std::condition_variable）并不单独作为锁，而是与互斥锁结合使用。它允许线程在等待某个条件满足时被阻塞，并在条件满足时被唤醒。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>std::mutex mtx;
std::condition_variable cv;
bool ready = false;void worker() {std::unique_lock<std::mutex> lock(mtx);// lock_guard 没有 unlock()/lock() 接口，生命周期内“始终持有”是它的契约；而 unique_lock 提供了这些成员函数并允许临时失去所有权// lock_guard 的设计是极简 RAII：构造即上锁、析构即解锁，中间不允许变更持锁状态，也不可移动。// unique_lock 的设计是“可拥有/可转移/可显式 lock/unlock/release”，契合 wait 在等待期间修改持锁状态的需求。// 这是 条件变量的“带谓词等待” 用法。// cv.wait(lock, [] { return ready; }); 的意思是：在持有 lock（一个 std::unique_lock<std::mutex>）的前提下，一直等到 ready 为 true 才返回；否则就阻塞等待通知。cv.wait(lock, [] { return ready; }); // 等待条件变量std::cout << "Worker thread is running..." << std::endl;
}void signal() {std::lock_guard<std::mutex> lock(mtx);ready = true;std::cout << "signal thread is running..." << std::endl;cv.notify_one(); // 唤醒等待中的线程
}int main() {std::thread t1(worker);std::thread t2(signal);t1.join();t2.join();return 0;
}

87. 内存对齐是什么，为什么要做内存对齐

88. 结构体和联合体的区别？

#include <iostream>
#include <cstring>  // 用于使用 strcpyunion Data {int i;float f;char str[20];
};int main() {Data data;  // 创建一个联合体变量// 使用 int 成员data.i = 42;std::cout << "data.i: " << data.i << std::endl;// 使用 float 成员data.f = 3.14;std::cout << "data.f: " << data.f << std::endl;// 使用字符串成员strcpy(data.str, "Hello");std::cout << "data.str: " << data.str << std::endl;// 观察内存重用的效果,可能会出现未定义的 乱七八糟的内容std::cout << "After setting data.str, data.i: " << data.i << std::endl;std::cout << "After setting data.str, data.f: " << data.f << std::endl;return 0;
}//上面的代码输出 可能输出下面的结果
// data.i: 42 
// data.f: 3.14 
// data.str: Hello After setting data.str, data.i: 1819043144  // 这些值可能是未定义的行为 
// After setting data.str, data.f: 1.15282e+09 // 因为内存已经被str覆盖

89. struct和class的区别？

90. 为什么TCP握手是3次，不能是2次和4次吗？

之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！