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次嗎？

之后我會持續更新，如果喜歡我的文章，請記得一鍵三連哦，點贊關注收藏，你的每一個贊每一份關注每一次收藏都將是我前進路上的無限動力 ！！！↖(▔▽▔)↗感謝支持！