【面试】解释自旋锁和互斥锁的区别

面试模拟场景

面试官: 你能解释一下自旋锁和互斥锁的区别吗？

参考回答示例

1. 自旋锁（Spinlock）

定义:

• 自旋锁是一种轻量级的锁机制，当一个线程尝试获取锁时，如果锁已经被其他线程持有，当前线程不会进入休眠或阻塞状态，而是会不断地循环检查（“自旋”）锁是否已经释放，直到获取锁为止。

工作机制:

• 自旋: 当线程未能获取锁时，它会在一个循环中反复检查锁的状态，这种忙等状态称为自旋。
• 避免上下文切换: 自旋锁不会引起线程上下文切换，因此开销较小，适合用于锁定时间非常短的临界区。

优缺点:

• 优点: 自旋锁适合用于锁定时间非常短的临界区，因为避免了线程的上下文切换，减少了系统开销。
• 缺点: 如果锁的持有时间较长，自旋会消耗大量的CPU资源，可能导致性能下降。

应用场景:

• 自旋锁适用于锁定时间非常短的临界区，以及在多处理器系统中，线程在不同的处理器上运行时使用自旋锁可以避免频繁的上下文切换。

2. 互斥锁（Mutex）

定义:

• 互斥锁（Mutex, Mutual Exclusion Lock） 是一种常见的线程同步机制，当一个线程尝试获取锁时，如果锁已经被其他线程持有，当前线程会被挂起进入阻塞状态，直到锁被释放，系统会唤醒该线程并让它继续执行。

工作机制:

• 阻塞: 当线程未能获取锁时，线程会进入阻塞状态，操作系统会将该线程挂起，并将CPU资源分配给其他线程。
• 上下文切换: 当锁被释放时，操作系统会唤醒阻塞的线程，这会导致线程上下文切换，进而带来一定的开销。

优缺点:

• 优点: 互斥锁适用于锁定时间较长的临界区，因为线程会被阻塞，而不是消耗CPU资源。
• 缺点: 上下文切换的开销较大，在多线程竞争激烈的情况下，频繁的上下文切换可能导致性能下降。

应用场景:

• 互斥锁适用于锁定时间较长的临界区，以及当线程竞争资源时的情况，能够避免CPU资源的浪费。

3. 自旋锁和互斥锁的对比

方面	自旋锁（Spinlock）	互斥锁（Mutex）
锁定方式	自旋等待（忙等）	阻塞等待
CPU开销	高（在未获得锁时仍消耗CPU资源）	低（未获得锁时进入阻塞状态，不消耗CPU资源）
上下文切换	不涉及上下文切换	涉及线程上下文切换，开销较大
适用场景	适用于锁定时间非常短的临界区	适用于锁定时间较长的临界区
多处理器系统	在多处理器系统中更有效	在单处理器和多处理器系统中均适用
线程等待	线程一直在循环检查锁的状态	线程被阻塞，等待锁释放后被唤醒

4. 具体例子

例子1: 自旋锁的应用

在多核系统中，当临界区内的操作非常简单且耗时非常短时，自旋锁可以是一个高效的选择。假设我们有一个高性能网络服务器，需要记录所有处理的请求数。请求计数器的更新操作非常简单（如递增一个整数），而且频率极高。

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

// 定义一个自旋锁使用的原子标志，初始化为未设置状态（即未加锁）
std::atomic_flag spinlock = ATOMIC_FLAG_INIT;

// 共享的全局计数器，将被多个线程更新
int requestCounter = 0;

// 模拟处理请求的函数
void processRequest() {
    // 每个线程将执行 100,000 次计数器递增操作
    for (int i = 0; i < 100000; ++i) {
        // 自旋锁：在锁被占用时，自旋等待，直到锁被释放
        while (spinlock.test_and_set(std::memory_order_acquire)) {
            // 忙等待，直到其他线程释放锁
        }

        // 获得锁后进入临界区，对共享计数器进行递增操作
        ++requestCounter;

        // 离开临界区，释放锁，允许其他线程进入
        spinlock.clear(std::memory_order_release);
    }
}

int main() {
    const int numThreads = 4;  // 定义线程数量
    std::vector<std::thread> threads;  // 用于存储线程对象的向量

    // 创建并启动多个线程，每个线程都执行 processRequest 函数
    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(processRequest);
    }

    // 等待所有线程执行完毕
    for (auto &t : threads) {
        t.join();
    }

    // 输出最终的计数器值
    std::cout << "Total requests processed: " << requestCounter << std::endl;
    return 0;
}

例子2: 互斥锁的应用

在大多数服务器应用中，数据库连接池是一个常见的组件。一个数据库连接池管理着若干个数据库连接，以供多线程使用。对数据库连接池的访问需要使用互斥锁，以确保在同一时刻只有一个线程可以借用或归还连接。假设我们有一个简单的数据库连接池，它允许多个线程借用和归还数据库连接。

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <queue>
#include <chrono>

// 模拟的数据库连接类
class DatabaseConnection {
public:
    // 模拟执行查询的函数
    void query() {
        // 模拟数据库查询操作，假设需要 50 毫秒
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
        std::cout << "Query executed by thread " << std::this_thread::get_id() << std::endl;
    }
};

// 数据库连接池类，管理一组数据库连接
class ConnectionPool {
public:
    // 构造函数，初始化连接池，指定池中连接的数量
    ConnectionPool(int size) {
        for (int i = 0; i < size; ++i) {
            connections.push(new DatabaseConnection());
        }
    }

    // 析构函数，清理连接池中的所有连接
    ~ConnectionPool() {
        while (!connections.empty()) {
            delete connections.front();
            connections.pop();
        }
    }

    // 借用连接的函数，返回一个可用的数据库连接
    DatabaseConnection* borrowConnection() {
        std::lock_guard<std::mutex> lock(mtx);  // 获取互斥锁，保护连接池队列的访问
        if (connections.empty()) {
            // 如果没有可用的连接，返回 nullptr
            return nullptr;
        }
        // 获取队列头部的连接，并将其从队列中移除
        DatabaseConnection* conn = connections.front();
        connections.pop();
        return conn;
    }

    // 归还连接的函数，将连接返回到池中
    void returnConnection(DatabaseConnection* conn) {
        std::lock_guard<std::mutex> lock(mtx);  // 获取互斥锁，保护连接池队列的访问
        connections.push(conn);  // 将连接放回队列中
    }

private:
    std::queue<DatabaseConnection*> connections;  // 用于存储数据库连接的队列
    std::mutex mtx;  // 互斥锁，用于保护连接池的并发访问
};

// 模拟的工作线程函数，从连接池中借用连接，执行查询，然后归还连接
void worker(ConnectionPool &pool) {
    for (int i = 0; i < 5; ++i) {
        // 从连接池借用一个连接
        DatabaseConnection* conn = pool.borrowConnection();
        if (conn) {
            // 如果成功借到连接，执行查询
            conn->query();
            // 查询完成后，将连接归还到连接池
            pool.returnConnection(conn);
        } else {
            // 如果没有可用连接，输出提示信息
            std::cout << "No available connection for thread " << std::this_thread::get_id() << std::endl;
        }
    }
}

int main() {
    ConnectionPool pool(3);  // 创建一个连接池，池中有 3 个连接

    std::vector<std::thread> threads;  // 用于存储线程对象的向量

    // 创建并启动多个线程，每个线程都执行 worker 函数
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(worker, std::ref(pool));
    }

    // 等待所有线程执行完毕
    for (auto &t : threads) {
        t.join();
    }

    return 0;
}

5. 总结

自旋锁和互斥锁都是用于多线程编程中的同步机制，但它们在实现方式和应用场景上有所不同。自旋锁适合锁定时间短的场景，因为它避免了线程上下文切换，但在锁定时间较长时可能会浪费大量的CPU资源。互斥锁适合锁定时间较长的场景，因为线程在未获得锁时会进入阻塞状态，从而避免了CPU资源的浪费。根据具体应用的需求，选择合适的锁机制可以提高系统的性能和效率。