在 C++ 多线程编程中，线程同步是确保程序正确运行的关键环节，而锁机制则是实现线程同步的重要手段。

一、线程的同步之互斥锁

1.1 互斥锁的概念

互斥锁（Mutex，即 Mutual Exclusion 的缩写）是一种最基本的线程同步工具，用于保证在同一时刻只有一个线程能够访问共享资源，从而避免数据竞争和不一致的问题。其工作原理就像一个房间的钥匙，同一时间只有拿到钥匙的线程才能进入房间（访问共享资源），其他线程必须等待钥匙被释放后才能尝试获取。

1.2 互斥锁的使用场景

当多个线程需要访问和修改共享数据，且这些操作不是原子操作时，就需要使用互斥锁来保护共享数据。例如，在一个多线程的银行账户管理系统中，多个线程可能同时对账户余额进行取款和存款操作，如果不加以同步，就可能导致账户余额出现错误。

1.3 互斥锁的使用方法

在 C++ 中，使用头文件来操作互斥锁。

#include <iostream>
#include <mutex>
#include <thread>

std::mutex mtx;
int sharedData = 0;

void increment() {
    mtx.lock();
    sharedData++;
    mtx.unlock();
}

int main() {
    std::thread threads[10];
    for (int i = 0; i < 10; ++i) {
        threads[i] = std::thread(increment);
    }

    for (auto& th : threads) {
        th.join();
    }

    std::cout << "Final value of sharedData: " << sharedData << std::endl;
    return 0;
}

std::thread threads[10];：定义了一个包含 10 个 std::thread 对象的数组 threads，用于存储创建的线程。
for (int i = 0; i < 10; ++i) { threads[i] = std::thread(increment); }：使用 for 循环创建 10 个线程，每个线程都执行 increment 函数。std::thread(increment) 会启动一个新线程并将 increment 函数作为线程的执行体。
for (auto& th : threads) { th.join(); }：使用范围 for 循环遍历 threads 数组，调用每个线程的 join 方法。join 方法会阻塞主线程，直到对应的子线程执行完毕。这样可以确保主线程在所有子线程执行完毕后再继续执行后续代码。

std::mutex mtx定义了一个互斥锁，increment函数在访问和修改sharedData之前，先通过mtx.lock()获取锁，操作完成后通过mtx.unlock()释放锁，确保了同一时间只有一个线程能修改sharedData。

二、读写锁

2.1 读写锁的概念

读写锁（Read-Write Lock）是一种特殊的同步机制，它区分了读操作和写操作。允许多个线程同时进行读操作，因为读操作不会修改共享数据，不会产生数据竞争；但只允许一个线程进行写操作，并且在写操作时不允许其他线程进行读或写操作，以保证数据的一致性。

2.2 读写锁的使用场景

当共享资源的读操作远远多于写操作时，使用读写锁可以显著提高程序的性能。例如，在一个多线程的数据库查询系统中，大量线程可能同时进行数据查询（读操作），而只有少数线程会进行数据更新（写操作）。

2.3 读写锁的使用方法

在 C++ 中，可以使用<shared_mutex>头文件来操作读写锁。

#include <iostream>
#include <shared_mutex>
#include <thread>

std::shared_mutex rwMutex;
int sharedValue = 0;

void read() {
    rwMutex.lock_shared();
    std::cout << "Reading value: " << sharedValue << std::endl;
    rwMutex.unlock_shared();
}

void write() {
    rwMutex.lock();
    sharedValue++;
    std::cout << "Writing value: " << sharedValue << std::endl;
    rwMutex.unlock();
}

int main() {
    std::thread readThreads[5];
    std::thread writeThread(write);

    for (int i = 0; i < 5; ++i) {
        readThreads[i] = std::thread(read);
    }

    for (auto& th : readThreads) {
        th.join();
    }

    writeThread.join();
    return 0;
}

std::shared_mutex rwMutex定义了一个读写锁。read函数使用lock_shared进行读锁定，允许多个线程同时读；write函数使用lock进行写锁定，确保同一时间只有一个线程能写。

三、互斥锁非阻塞式锁

3.1 非阻塞式锁的概念

非阻塞式锁是指线程在尝试获取锁时，如果锁当前被其他线程占用，不会阻塞等待，而是立即返回一个状态值，告知线程获取锁的结果，线程可以根据这个结果决定后续的操作。

3.2 非阻塞式锁的使用场景

在一些对响应时间要求较高，且线程不能长时间阻塞的场景中，非阻塞式锁非常有用。例如，在一个实时性要求较高的图形界面应用中，线程需要快速响应用户的操作，不能因为等待锁而导致界面卡顿。

3.3 非阻塞式锁的使用方法

在 C++ 中，std::mutex提供了try_lock方法来实现非阻塞式加锁。

#include <iostream>
#include <mutex>
#include <thread>

std::mutex mtx;
int sharedResource = 0;

void attemptAccess() {
    if (mtx.try_lock()) {
        std::cout << "Thread got the lock." << std::endl;
        sharedResource++;
        mtx.unlock();
    } else {
        std::cout << "Thread couldn't get the lock." << std::endl;
    }
}

int main() {
    std::thread threads[3];
    for (int i = 0; i < 3; ++i) {
        threads[i] = std::thread(attemptAccess);
    }

    for (auto& th : threads) {
        th.join();
    }

    return 0;
}

attemptAccess函数使用try_lock尝试获取锁，如果获取成功则进行操作，否则直接返回。

四、读写锁非阻塞式上锁

4.1 读写锁非阻塞式上锁的概念

与互斥锁的非阻塞式上锁类似，读写锁的非阻塞式上锁允许线程在尝试获取读锁或写锁时，如果锁被占用，不会阻塞等待，而是立即返回结果，以便线程灵活处理。

4.2 读写锁非阻塞式上锁的使用场景

在一些需要快速响应，且读操作和写操作都不能长时间阻塞的场景中适用。比如在一个高速缓存系统中，线程需要快速判断能否获取锁来进行数据的读取或更新，而不是一直等待锁的释放。

4.3 读写锁非阻塞式上锁的使用方法

在 C++ 中，std::shared_mutex提供了try_lock_shared和try_lock方法来实现非阻塞式的读锁和写锁获取

#include <iostream>
#include <shared_mutex>
#include <thread>

std::shared_mutex rwMutex;
int sharedData = 0;

void tryRead() {
    if (rwMutex.try_lock_shared()) {
        std::cout << "Thread got read lock. Data: " << sharedData << std::endl;
        rwMutex.unlock_shared();
    } else {
        std::cout << "Thread couldn't get read lock." << std::endl;
    }
}

void tryWrite() {
    if (rwMutex.try_lock()) {
        sharedData++;
        std::cout << "Thread got write lock. Data updated: " << sharedData << std::endl;
        rwMutex.unlock();
    } else {
        std::cout << "Thread couldn't get write lock." << std::endl;
    }
}

int main() {
    std::thread readThreads[3];
    std::thread writeThread(tryWrite);

    for (int i = 0; i < 3; ++i) {
        readThreads[i] = std::thread(tryRead);
    }

    for (auto& th : readThreads) {
        th.join();
    }

    writeThread.join();
    return 0;
}

tryRead函数使用try_lock_shared尝试获取读锁，tryWrite函数使用try_lock尝试获取写锁，根据获取结果进行相应操作。

线程同步中的各类锁机制是 C++ 多线程编程的重要组成部分。互斥锁用于基本的线程同步，读写锁适用于读多写少的场景，非阻塞式锁则为需要快速响应的场景提供了解决方案。