1. lock_guard和unique_lock区别
下面是 lock_guard 和 unique_lock 的简单使用示例，可以看出二者在使用方法上的区别
示例：用std::lock_guard加互斥锁
示例：用std::unique_lock加互斥锁并手动释放锁
使用{}来控制轻锁lock_guard的生命周期
lock_guard和unique_lock区别
lock_guard 和 unique_lock 都是 C++ 标准库提供的互斥锁 RAII 封装工具，用于实现互斥访问，但它们有一些不同之处：
lock_guard 是基于互斥锁 std::mutex 实现的，unique_lock 是基于通用锁 std::unique_lock 实现的，unique_lock 可以实现比 lock_guard 更灵活的锁操作。
lock_guard 是不可移动的（moveable），即不能拷贝、赋值、移动，只能通过构造函数初始化和析构函数销毁，unique_lock 是可移动的，可以拷贝、赋值、移动。
unique_lock 提供了更多的控制锁的行为，比如锁超时、不锁定、条件变量等。
unique_lock 比 lock_guard 更重，因为它有更多的功能，更多的开销。如果只需要简单的互斥保护，使用 lock_guard 更好。
另外，unique_lock 支持手动解锁，而 lock_guard 不支持。
下面是 lock_guard 和 unique_lock 的简单使用示例，可以看出二者在使用方法上的区别
-
-
-
-
-
std::mutex m;
-
-
void worker()
-
{
-
std::lock_guard<std::mutex> lg(m); // lock_guard 方式上锁
-
std::cout << "worker thread is running..." << std::endl;
-
// 这里可以写一些需要互斥保护的代码
-
std::this_thread::sleep_for(std::chrono::seconds(1));
-
std::cout << "worker thread is done." << std::endl;
-
} // lock_guard 不支持手动解锁，会在此自动释放锁
-
-
void another_worker()
-
{
-
std::unique_lock<std::mutex> ul(m); // unique_lock 方式上锁
-
std::cout << "another worker thread is running..." << std::endl;
-
// 这里可以写一些需要互斥保护的代码
-
std::this_thread::sleep_for(std::chrono::seconds(1));
-
std::cout << "another worker thread is done." << std::endl;
-
ul.unlock(); // 手动释放锁
-
//do something...
-
} // 如果锁未释放，unique_lock 会在此自动释放锁
-
-
int main()
-
{
-
std::thread t1(worker);
-
std::thread t2(another_worker);
-
t1.join();
-
t2.join();
-
return 0;
-
}
编译运行结果：
-
g++ test.cpp -lpthread && ./a.out
-
1
2. 用std::lock_guard加互斥锁
std::lock_guard 是 C++11 中的标准库，是一个实现互斥锁的简单模板类。
它的使用方法很简单，只需要在代码中创建一个 std::lock_guard 对象，并传入一个互斥锁，在它的生命周期内，互斥锁的访问权限将被控制。
-
-
-
-
-
-
-
std::mutex mtx;
-
std::vector<int> data;
-
-
void func1()
-
{
-
std::lock_guard<std::mutex> lock(mtx); // 创建 lock_guard 对象
-
for (int i = 0; i < 10; ++i)
-
{
-
data.push_back(i);
-
std::cout << "func1: " << i << std::endl;
-
std::this_thread::sleep_for(std::chrono::seconds(1));
-
}
-
}
-
-
void func2()
-
{
-
std::lock_guard<std::mutex> lock(mtx); // 创建 lock_guard 对象
-
for (int i = 100; i < 110; ++i)
-
{
-
data.push_back(i);
-
std::cout << "func2: " << i << std::endl;
-
std::this_thread::sleep_for(std::chrono::seconds(1));
-
}
-
}
-
-
int main()
-
{
-
std::thread thrd1(func1);
-
std::thread thrd2(func2);
-
-
thrd1.join();
-
thrd2.join();
-
-
for (auto &i : data)
-
{
-
std::cout << i << " ";
-
}
-
std::cout << std::endl;
-
return 0;
-
}
编译运行：
-
g++ test.cpp -lpthread && ./a.out
-
1
3. 用std::unique_lock加互斥锁并手动释放锁
在 C++ 中，互斥锁通常是通过 RAII 机制来保证自动释放，即在锁对象的生命周期结束时自动释放锁。但是，在某些情况下，可能需要手动释放互斥锁。在 C++11 中，可以通过 std::unique_lock::unlock() 方法来手动释放互斥锁。
下面是一个简单的示例代码，演示了如何手动释放互斥锁：
-
-
-
-
-
-
std::mutex g_mutex;
-
int count = 0;
-
-
void func()
-
{
-
std::unique_lock<std::mutex> lock(g_mutex);
-
std::cout << "Thread " << std::this_thread::get_id() << " acquired the lock." << std::endl;
-
count++;
-
std::cout << "Thread " << std::this_thread::get_id() << " count = " << count << std::endl;
-
lock.unlock(); // 手动释放互斥锁 //如果不手动释放，锁会在函数结束时自动释放
-
std::cout << "Thread " << std::this_thread::get_id() << " released the lock." << std::endl;
-
//do somethine...
-
std::this_thread::sleep_for(std::chrono::seconds(1));
-
}
-
-
int main()
-
{
-
const int numThreads = 1000;
-
-
std::thread threads[numThreads];
-
for (int i = 0; i < numThreads; ++i) {
-
threads[i] = std::thread(func);
-
}
-
-
for (int i = 0; i < numThreads; ++i) {
-
threads[i].join();
-
}
-
-
std::cout << "final count = " << count << std::endl;
-
-
return 0;
-
}
编译运行结果：
-
g++ test.cpp -lpthread && ./a.out
-
1
4. 使用{}来控制轻锁lock_guard的生命周期
当使用{}括起来的代码块创建std::lock_guard对象时，std::lock_guard的生命周期将仅限于该代码块内部。
std::lock_guard是一个在构造函数中获取互斥锁，在析构函数中释放互斥锁的RAII类。当std::lock_guard对象的生命周期结束时，它会自动释放所持有的互斥锁，以避免出现死锁和其他相关的问题。
当您在代码块中创建std::lock_guard对象时，它的析构函数将在代码块结束时自动调用，从而释放锁。这意味着锁的作用范围将仅限于该代码块内部，并且在代码块外部无法访问该锁。
下面是一个示例代码，演示了如何在代码块内使用std::lock_guard对象：
-
-
-
std::mutex m; // 互斥锁
-
-
void foo()
-
{
-
{
-
std::lock_guard<std::mutex> guard(m); // 创建 std::lock_guard 对象
-
// 在这个代码块中，互斥锁 m 被锁定
-
// 执行一些需要互斥访问的代码
-
} // std::lock_guard 对象在这里销毁，互斥锁 m 被解锁
-
// 在这个代码块外，无法访问锁 m
-
}
完整测试代码：
-
-
-
-
-
-
std::mutex m; // 互斥锁
-
int shared_data = 0; // 共享数据
-
-
void worker(int id)
-
{
-
// 在循环中修改共享数据
-
for (int i = 0; i < 5; ++i)
-
{
-
{
-
std::lock_guard<std::mutex> guard(m); // 创建 std::lock_guard 对象
-
shared_data++; // 修改共享数据
-
std::cout << "Worker " << id << " modified shared data to " << shared_data << std::endl;
-
} //销毁lock_guard，释放锁
-
printf("Worker %d relead lock.......................................\n", id);
-
std::this_thread::sleep_for(std::chrono::seconds(1));
-
printf("Worker %d has sleep 1 second.......................................\n", id);
-
} // std::lock_guard 对象在这里销毁，互斥锁 m 被解锁
-
}
-
-
int main()
-
{
-
std::thread t1(worker, 1);
-
std::thread t2(worker, 2);
-
-
t1.join();
-
t2.join();
-
-
std::cout << "Final value of shared data is " << shared_data << std::endl;
-
-
return 0;
-
}
在上面的示例代码中，有两个线程t1和t2，它们同时访问共享数据shared_data。为了避免数据竞争和其他并发问题，我们使用了std::mutex和std::lock_guard来确保只有一个线程可以访问共享数据。
在worker()函数中，我们使用了std::lock_guard对象guard来锁定互斥锁m，以确保每个线程在修改共享数据时都能够获得锁。当std::lock_guard对象在代码块末尾销毁时，互斥锁将自动解锁，从而允许其他线程访问共享数据。
在main()函数中，我们创建了两个线程t1和t2，它们分别执行worker()函数。我们使用t1.join()和t2.join()等待线程执行完毕，然后输出最终的共享数据值。
编译运行结果：
原文链接：https://blog.csdn.net/Dontla/article/details/129030629