C++ mutex 上锁简单测试

#include <string>
#include <mutex>
#include <iostream>

using namespace std;
namespace
{
    //std::mutex m;
    std::recursive_mutex m; // 可递归
    class Test
    {
    public:
        void test1()
        {
            std::lock_guard<std::recursive_mutex> lock(m);
        }
        void test2()
        {
            std::lock_guard<std::recursive_mutex> lock(m);
            test1();
            cout << "test2()" << endl;
        }
    };
}

#if 1

int main()
{
    Test t;
    t.test2();

    return 0;
}

#endif

输出：

test2()

递归上锁用recursive_mutex，否则会崩。

std::unique_lock 支持手动加锁和解锁：

std::unique_lock<std::mutex> lock(mtx, std::defer_lock); // 延迟加锁
lock.lock(); // 手动加锁
// 操作共享数据
lock.unlock(); // 手动解锁

与条件变量配合

std::unique_lock 是唯一可以与 std::condition_variable 配合使用的锁类型：

std::condition_variable cv;
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, []{ return shared_data > 0; }); // 等待条件满足

简单生产者和消费者示例：

std::queue<int> data_queue; // 共享队列
std::mutex mtx; // 互斥锁
std::condition_variable cv; // 条件变量

void producer(int id) 
{
	for (int i = 0; i < 5; ++i) 
	{
		std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟生产耗时
		{
			std::unique_lock<std::mutex> lock(mtx); // 加锁
			data_queue.push(i); // 生产数据
			std::cout << "Producer " << id << " produced: " << i << std::endl;
		} // 自动解锁
		cv.notify_one(); // 通知一个消费者
	}
}

void consumer(int id) 
{
	while (true) 
	{
		std::unique_lock<std::mutex> lock(mtx); // 加锁
												// 等待条件满足（队列不为空）
		cv.wait(lock, [] { return !data_queue.empty(); });

		// 消费数据
		int data = data_queue.front();
		data_queue.pop();
		std::cout << "Consumer " << id << " consumed: " << data << std::endl;

		lock.unlock(); // 手动解锁（可选）
	}
}

int main() 
{
	std::thread producers[2];
	std::thread consumers[2];

	// 启动生产者线程
	for (int i = 0; i < 2; ++i) {
		producers[i] = std::thread(producer, i + 1);
	}

	// 启动消费者线程
	for (int i = 0; i < 2; ++i) {
		consumers[i] = std::thread(consumer, i + 1);
	}

	// 等待生产者线程完成
	for (auto& t : producers) {
		t.join();
	}

	// 等待消费者线程完成（这里消费者是无限循环，需要手动终止）
	for (auto& t : consumers) {
		t.detach(); // 分离线程（或使用其他方式终止）
	}

	std::cout << "Main thread finished." << std::endl;
	return 0;
}