在 Linux 环境下进行 C++ 编程时，多线程能显著提升程序的并发处理能力，让程序在面对复杂任务时表现得更加高效。但多线程编程并非一帆风顺，死锁问题就像隐藏在暗处的 “杀手”，随时可能让程序陷入僵局。想象一下，你的程序原本运行得好好的，突然就像被施了定身咒一样，毫无反应，所有的线程都被卡住，无法继续推进。这很可能就是死锁在作祟。

死锁一旦发生，程序就像陷入了一个无法自拔的循环，各个线程相互等待对方释放资源，却又都不肯率先放手，最终导致整个程序停滞不前。这种情况不仅会让程序的功能无法正常实现，还可能影响整个系统的稳定性。比如在一个网络服务器程序中，如果发生死锁，可能会导致服务器无法响应新的客户端请求，大量用户的操作被搁置，后果不堪设想。

对于 C++ 开发者而言，掌握排查死锁的技巧至关重要。今天，我们就来深入探讨如何借助 Linux 系统下的 Shell 命令和强大的调试工具 GDB，精准定位并解决死锁问题，让你的程序重新 “活” 过来。

一、死锁概述

在多线程编程的领域中，死锁是一个让人头疼不已的问题。简单来说，死锁就是多个线程因为互相争夺资源，而陷入一种无限期的等待状态，导致所有线程都无法继续执行 。就好比两个人过独木桥，独木桥一次只能容纳一个人通过，这两个人同时上了桥，一个从左边往右边走，另一个从右边往左边走，走到桥中间时，谁也不愿意退回去让对方先过，于是就僵持在那里，谁都无法到达对岸，这就是死锁在现实生活中的生动写照。

在程序里，死锁通常发生在多个线程需要获取多个共享资源的时候。比如，线程 A 持有资源 1，并且想要获取资源 2；而线程 B 持有资源 2，却想要获取资源 1。此时，两个线程都在等待对方释放自己需要的资源，谁也不肯先放手，就形成了死锁。

死锁一旦发生，带来的危害是巨大的。程序会陷入无响应状态，无法正常完成任务，这对于那些需要实时响应的系统，如服务器程序、嵌入式系统等来说，是灾难性的。而且，死锁很难被发现和调试，因为它不是代码语法错误，也不是简单的逻辑错误，往往需要借助特定的工具和方法才能排查出来。

所以，学会如何排查死锁就显得尤为重要。在 Linux C++ 编程环境中，利用 shell 命令和强大的调试工具 gdb，我们可以有效地找出死锁的根源，让程序重新回到正常运行的轨道。接下来，就让我们一起深入学习如何使用 shell + gdb 来排查死锁。

二、死锁产生原因

在实际编写项目的过程中，经常涉及到多线程。多线程的程序编程很大概率会涉及到线程安全的问题，因此往往使用互斥锁来保证线程安全。

然而，互斥锁的使用却经常会导致另外一个问题：死锁。所谓死锁，通俗的讲就是有两个共享资源，一个在你手上，一个在我手上。我等着你用完把另一个给我，你等我用完给你，这样相互等待就形成了死锁。

死锁的产生往往源于对共享资源的不当管理和线程调度的不合理。下面我们来详细分析一下死锁产生的常见原因，并结合具体的代码示例进行解释。

2.1加锁顺序不当

当多个线程需要获取多个锁时，如果它们获取锁的顺序不一致，就很容易导致死锁。例如，有两个线程 thread1 和 thread2，它们都需要获取锁 mutex1 和 mutex2。thread1 先获取 mutex1，然后尝试获取 mutex2；而 thread2 先获取 mutex2，然后尝试获取 mutex1。如果在 thread1 获取了 mutex1 之后，thread2 获取了 mutex2，此时两个线程就会互相等待对方释放自己需要的锁，从而陷入死锁。

#include <iostream>
#include <thread>
#include <mutex>std::mutex mutex1;
std::mutex mutex2;void thread1Function() {mutex1.lock();std::cout << "Thread 1: Acquired mutex1" << std::endl;std::this_thread::sleep_for(std::chrono::seconds(1));mutex2.lock();std::cout << "Thread 1: Acquired mutex2" << std::endl;mutex2.unlock();mutex1.unlock();
}void thread2Function() {mutex2.lock();std::cout << "Thread 2: Acquired mutex2" << std::endl;std::this_thread::sleep_for(std::chrono::seconds(1));mutex1.lock();std::cout << "Thread 2: Acquired mutex1" << std::endl;mutex1.unlock();mutex2.unlock();
}int main() {std::thread thread1(thread1Function);std::thread thread2(thread2Function);thread1.join();thread2.join();return 0;
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.

在这段代码中，thread1Function 和 thread2Function 函数中获取锁的顺序不同，这就为死锁的发生埋下了隐患。当两个线程同时运行时，很可能会出现死锁的情况。

2.2重复加锁

如果一个线程在已经持有某个锁的情况下，再次尝试获取该锁，而这个锁又不支持重入(即同一个线程多次获取同一把锁)，就会导致死锁。例如，使用 std::mutex 时，如果一个线程在已经锁定了 std::mutex 的情况下，再次调用 lock 方法，就会陷入死锁，因为它无法再次获取已经持有的锁，而其他线程也无法获取该锁，从而导致所有线程都无法继续执行。

#include <iostream>
#include <thread>
#include <mutex>std::mutex myMutex;void recursiveFunction(int count) {myMutex.lock();std::cout << "Entering recursiveFunction, count: " << count << std::endl;if (count > 0) {recursiveFunction(count - 1);}myMutex.unlock();std::cout << "Exiting recursiveFunction, count: " << count << std::endl;
}int main() {std::thread myThread(recursiveFunction, 3);myThread.join();return 0;
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.

在这个例子中，recursiveFunction 函数是递归的，每次调用都会尝试获取 myMutex 锁。由于 std::mutex 不支持重入，当递归调用时，第二次获取锁就会导致死锁。

2.3加锁后未解锁

如果一个线程获取了锁，但由于某些原因(如异常、逻辑错误等)没有释放锁，那么其他需要获取该锁的线程就会一直等待，从而导致死锁。比如，在下面的代码中，如果 someFunction 函数在执行过程中抛出异常，那么 mutex 锁将不会被释放，后续尝试获取该锁的线程就会陷入死锁。

#include <iostream>
#include <thread>
#include <mutex>std::mutex mutex;void someFunction() {mutex.lock();std::cout << "Locked the mutex" << std::endl;// 模拟一些可能抛出异常的操作throw std::runtime_error("Something went wrong");mutex.unlock();std::cout << "Unlocked the mutex" << std::endl;
}int main() {std::thread thread(someFunction);thread.join();return 0;
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.

在实际编程中，为了避免这种情况，通常会使用 try - catch 块来捕获异常，并在 catch 块中释放锁，或者使用 std::lock_guard 等 RAII(Resource Acquisition Is Initialization)机制来自动管理锁的生命周期，确保锁在离开作用域时自动释放。

了解了死锁产生的原因后，我们就可以有针对性地进行排查和解决。接下来，我们将学习如何使用 shell 和 gdb 工具来发现和定位死锁问题。