C++ STL中递归锁与普通锁的区别

在多线程编程中，保护共享资源的访问很重要，为了实现这个目标，C++标准库（STL）中提供了多种锁，如std::mutex和std::recursive_mutex。这篇文章将介绍递归锁和普通锁的区别。

一、普通锁（std::mutex）

普通锁是C++ STL中的基本锁类型，它可以防止多个线程同时访问同一个共享资源。当一个线程获得普通锁后，其他试图获取该锁的线程将被阻塞，直到锁被释放。使用std::mutex时需要注意以下几点：

1. 普通锁不支持递归锁定。也就是说，当一个线程已经获取了锁，再次尝试获取同一个锁会导致死锁。

2. 普通锁的性能较高，因为它没有额外的递归计数开销。

3. 普通锁可以和C++11中的std::unique_lock和std::lock_guard一起使用，以便在异常安全的情况下管理锁的生命周期。

二、递归锁（std::recursive_mutex）

递归锁是一种特殊类型的锁，它允许同一个线程多次获取同一个锁。每次获取锁时，递归锁的计数器会增加，当释放锁时，计数器减少。只有当计数器为0时，锁才会被真正释放。使用std::recursive_mutex需要注意以下几点：

1. 递归锁支持递归锁定，避免了死锁的发生。同一个线程可以多次获取同一个锁，但必须确保释放次数与获取次数相同。

2. 递归锁的性能略低于普通锁，因为需要维护递归计数器。

3. 递归锁可以和C++11中的std::unique_lock一起使用，以便在异常安全的情况下管理锁的生命周期。

三、递归锁与普通锁的选择

在实际编程中，选择哪种锁取决于具体的应用场景：

1. 如果代码中不存在递归调用，推荐使用普通锁，因为它的性能较高。

2. 如果代码中存在递归调用，并且锁需要在递归过程中持有，那么选择递归锁是更合适的。但请注意，过多地使用递归锁可能会导致代码难以理解和维护。

总之，在多线程编程中，了解锁的类型和适用场景是很重要的。递归锁（std::recursive_mutex）和普通锁（std::mutex）在功能和性能上有一定的差异。在选择使用哪种锁时，开发者应根据实际需求和应用场景进行权衡。

在使用锁时，还需要注意以下几点：

1. 避免死锁：在多线程环境中，确保正确地获取和释放锁可以防止死锁。在适当的场景下使用递归锁可以降低死锁的风险。

2. 锁粒度：在设计多线程程序时，应权衡锁粒度。较大的锁粒度可能导致性能下降，而较小的锁粒度可能导致代码复杂度增加。选择合适的锁粒度以实现最佳性能和易维护性。

3. 异常安全：当异常发生时，确保锁被正确释放。可以使用std::unique_lock和std::lock_guard与锁结合，以实现RAII（Resource Acquisition Is Initialization）机制，自动管理锁的生命周期。

4. 优先考虑无锁编程：在某些场景下，无锁编程技术（如原子操作、无锁数据结构）可以提供更高的性能。在适当的场景下，无锁编程是值得考虑的替代方案。

总的来说，理解C++ STL中递归锁和普通锁的区别，可以帮助开发者在多线程编程中更好地保护共享资源，提高程序性能和稳定性。

下面是一些关于使用std::mutex（普通锁）和std::recursive_mutex（递归锁）的示例：

1. 使用std::mutex的示例：

   #include <iostream>
   #include <mutex>
   #include <thread>
   
   std::mutex mtx;
   int shared_counter = 0;
   
   void increment() {
       for (int i = 0; i < 100000; ++i) {
           std::unique_lock<std::mutex> lock(mtx);
           ++shared_counter;
           lock.unlock();
       }
   }
   
   int main() {
       std::thread t1(increment);
       std::thread t2(increment);
   
       t1.join();
       t2.join();
   
       std::cout << "共享计数器的值: " << shared_counter << std::endl;
   
       return 0;
   }
   

   在这个示例中，我们使用std::mutex保护对共享变量shared_counter的访问。当一个线程获取到锁时，另一个线程会被阻塞，直到锁被释放。

2. 使用std::recursive_mutex的示例：

   #include <iostream>
   #include <mutex>
   #include <thread>
   
   std::recursive_mutex rmtx;
   int shared_counter = 0;
   
   void recursive_increment(int depth) {
       if (depth <= 0) {
           return;
       }
   
       std::unique_lock<std::recursive_mutex> lock(rmtx);
       ++shared_counter;
       recursive_increment(depth - 1);
       lock.unlock();
   }
   
   int main() {
       const int depth = 10;
       std::thread t1(recursive_increment, depth);
       std::thread t2(recursive_increment, depth);
   
       t1.join();
       t2.join();
   
       std::cout << "共享计数器的值: " << shared_counter << std::endl;
   
       return 0;
   }
   

   在这个示例中，我们使用std::recursive_mutex保护对共享变量shared_counter的访问。recursive_increment函数递归地调用自身。递归锁允许同一个线程在递归过程中多次获取同一个锁，从而避免死锁。

   请注意，在实际应用中，我们应尽量避免不必要的递归锁使用，以减少性能开销和提高代码可读性。递归锁应仅在必要时使用，例如当代码中存在递归调用并且需要在递归过程中保持锁。