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
#endif

int data = 0;                 // 普通共享数据（非原子）
std::atomic<bool> ready{false}; // 原子标志：告诉对方“数据准备好了”

void producer() {
    data = 42; // 普通写：把共享数据准备好

#if USE_RELAXED
    // 没有发布语义：可能发生重排，消费者即便看到 ready=true，也未必能看到 data=42
    ready.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_RELAXED
    while (!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();          // 让出时间片，避免满负荷空转
    }
#endif

    int 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_RELAXED
            std::cout << "[relaxed] round " << i << ", seen=" << seen << "\n";
#else
            std::cout << "[acq/rel] round " << i << ", seen=" << seen << "\n";
#endif
        }
    }

#if USE_RELAXED
    std::cout << "[relaxed] failures = " << failures
              << " / " << rounds << " (未必容易复现，但理论上可能出错)\n";
#else
    std::cout << "[acquire/release] failures = " << failures
              << " / " << rounds << " (应始终为 0)\n";
#endif

    return 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>  // 用于使用 strcpy

union 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次吗？

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