C++ 代码中如何使用互斥锁std::mutex和独占锁std::unique_lock

创建一个C++线程需要传入几个参数？
如何理解和使用C++线程循环
C++ 类 函数 变量 进程 线程
C++关于锁和互斥量你真的理解了吗？

在这个例子中，我们将创建一个简单的类，该类包含一个共享数据成员和两个方法，这两个方法将通过互斥锁来同步对共享数据的访问。

1. SharedResource 类包含一个整数数据成员和一个互斥锁。
2. increment 和 decrement 方法使用 std::unique_lock 来锁定互斥锁。这保证了当一个线程在执行这些方法时，其他线程不能同时执行它们。
3. main 函数直接创建了两个线程，分别调用 SharedResource 类的 increment 和 decrement 方法。
   通过使用 std::thread 的构造函数，我们将类的成员函数和对象的地址传递给线程。这样做允许线程直接调用这些成员函数。
4. 通过使用互斥锁，我们确保了对共享资源的安全访问，避免了数据竞争。这个程序演示了在多线程环境中如何安全地访问和修改共享数据。

• t1.join();：这一行确保主线程等待 t1 线程结束。t1 是之前启动的线程，它执行了 incrementFunction 或类的 increment 方法。

• t2.join();：这一行确保主线程在继续执行之前，会等待 t2 线程结束。t2 是执行 decrementFunction 或类的 decrement 方法的线程。

使用 join() 的主要原因和优势是：

1. 确保线程完成：join() 确保程序中的其他逻辑只有在相关的线程执行完毕后才会执行。这对于依赖于线程结果的情况非常重要。

2. 防止程序过早结束：在主线程（通常是程序的入口点）中使用 join() 防止了主线程（程序）在子线程完成它们的工作之前结束。

3. 避免资源泄露：如果一个线程结束了它的执行，但没有被 join() 或 detach()（另一种处理线程的方式），程序将终止并显示一个错误。使用 join() 确保每个线程都有机会正确完成，避免了潜在的资源泄露。

在多数情况下，如果你创建了线程，你应该在某个点上调用 join()（或 detach()，取决于具体情况），以确保线程得到正确处理。在你的代码中，join() 被用来确保 t1 和 t2 线程在程序结束前完成它们的任务。

#include 
#include 
#include 

class SharedResource {
private:
    int data;
    std::mutex mtx;

public:
    SharedResource() : data(0) {}

    void increment() {
        std::unique_lock<std::mutex> lock(mtx);
        ++data;
        std::cout << "Data incremented to " << data << std::endl;
        // lock is released when it goes out of scope
    }

    void decrement() {
        std::unique_lock<std::mutex> lock(mtx);
        --data;
        std::cout << "Data decremented to " << data << std::endl;
        // lock is released when it goes out of scope
    }

    int getData() const {
        return data;
    }
};

int main() {
    SharedResource resource;

    std::thread t1(&SharedResource::increment, &resource);
    std::thread t2(&SharedResource::decrement, &resource);

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

    std::cout << "Final data value: " << resource.getData() << std::endl;

    return 0;
}

在 C++ 多线程编程中，join() 方法是 std::thread 类的一个非常重要的成员函数。当你在一个线程对象上调用 join() 方法时，调用它的线程（通常是主线程）将等待直到与该线程对象相关联的线程完成其执行。换句话说，join() 使得启动线程（例如主线程）暂停执行，直到被 join() 的线程结束其任务。

在你的代码中：

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