面试题：C++ 中锁的底层原理是什么？

在 C++ 中，锁（如 std::mutex）的底层原理主要依赖于操作系统的同步机制和硬件支持的原子操作。锁的实现通常涉及以下几个关键点：

1. 锁的基本概念

锁是一种同步机制，用于保护共享资源，确保同一时间只有一个线程可以访问这些资源。锁的核心功能包括：

加锁（Lock）：获取锁的所有权，如果锁已被其他线程持有，则当前线程进入阻塞状态。
解锁（Unlock）：释放锁的所有权，允许其他线程获取锁。

2. 锁的底层实现

锁的底层实现通常依赖于以下技术和机制：

（1）原子操作

锁的实现需要保证加锁和解锁操作的原子性，即这些操作不能被中断。
原子操作通常由硬件提供支持，例如 CAS（Compare-And-Swap） 指令。

CAS 指令的基本形式：

bool CAS(int* ptr, int expected, int new_value) {
    if (*ptr == expected) {
        *ptr = new_value;
        return true;
    }
    return false;
}

（2）自旋锁（Spinlock）

自旋锁是一种简单的锁实现，线程在获取锁时会不断尝试（自旋），直到成功获取锁。
自旋锁适用于锁持有时间较短的场景，避免线程切换的开销。

示例：

class Spinlock {
    std::atomic<bool> flag{false};
public:
    void lock() {
        while (flag.exchange(true, std::memory_order_acquire)) {}
    }
    void unlock() {
        flag.store(false, std::memory_order_release);
    }
};

（3）操作系统支持的同步机制

如果锁的竞争激烈或持有时间较长，自旋锁会导致 CPU 资源的浪费。此时，操作系统提供的同步机制（如 futex）可以更高效地管理线程的阻塞和唤醒。
futex（Fast Userspace Mutex）：
- futex 是 Linux 内核提供的一种同步机制，结合了用户空间的原子操作和内核空间的阻塞/唤醒机制。
- 当锁竞争激烈时，futex 会将线程放入等待队列并进入阻塞状态，直到锁被释放。

（4）互斥锁（Mutex）

std::mutex 是 C++ 标准库提供的互斥锁实现，通常基于操作系统的同步机制（如 futex）和原子操作。
互斥锁的实现可能包括：
- 一个原子变量，用于表示锁的状态（锁定或未锁定）。
- 一个等待队列，用于管理阻塞的线程。

3. 锁的实现示例

以下是一个简单的互斥锁实现，展示了锁的底层原理：

#include <atomic>
#include <thread>
#include <iostream>

class SimpleMutex {
    std::atomic<bool> locked{false}; // 锁状态
public:
    void lock() {
        while (locked.exchange(true, std::memory_order_acquire)) {
            // 自旋等待
        }
    }
    void unlock() {
        locked.store(false, std::memory_order_release);
    }
};

SimpleMutex mtx;
int sharedData = 0;

void increment() {
    for (int i = 0; i < 100000; ++i) {
        mtx.lock();
        ++sharedData;
        mtx.unlock();
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Shared data: " << sharedData << std::endl;
    return 0;
}