当前位置：文江博客话题详情

如何检测循环调用？

发布于 2024-12-02 12:46:36 字数 327 浏览 0 评论 0原文

我一直在寻找死锁的原因以及避免和检测死锁的策略/工具。

死锁的另一个潜在原因是阻塞函数以循环方式调用其他阻塞函数，因此最终调用永远不会返回。

有时这很难发现，特别是在非常大的项目中。

那么，是否有任何工具/库/技术可以自动检测程序中的循环调用？

编辑： 我主要使用 C 和 C++ 编写代码，因此，如果可能的话，请提供有关适用于这些语言的主题的任何信息。

尽管如此，似乎这个主题几乎没有在 SO 中涵盖，所以其他语言的答案也可以。 尽管如果有人认为相关，也许这些应该有一个自己的主题

谢谢。

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

若言繁花未落 2024-12-09 12:46:36

尝试获取相同的不可重入锁的循环（或递归）调用是最容易调试的阻塞场景之一：锁定是确定性的，并且可以轻松检查。当应用程序锁定时，启动调试器并查看堆栈跟踪以了解持有哪些锁以及原因。

至于锁定问题的一般解决方案......您可以查看一些提供互斥体排序的库，并检测您何时尝试锁定无序的互斥体。这种类型的解决方案正确实现可能很复杂，但是一旦到位，它就可以确保您不会进入死锁状态，因为它强制所有进程以相同的顺序获取锁（即，如果进程 A 持有锁 La，并且它尝试获取顺序正确的锁 Lb，那么它要么成功，要么锁定，但无论哪个进程持有锁 Lb 都不能尝试锁定 La，因为不满足顺序约束）。

回复收藏 0 原文

心房的律动 2024-12-09 12:46:36

如果您使用的是 Linux，则有 2 个 Valgrind 工具用于检测死锁和竞争条件： Helgrind ，DRD。它们是相辅相成的，值得检查它们的线程错误。

回复收藏 0 原文

清醇 2024-12-09 12:46:36

在 Linux 中，您可以使用 valgrind 来检测死锁，使用--tool=helgrind。

回复收藏 0 原文

两仪 2024-12-09 12:46:36

检测死锁 (IMO) 的最佳方法是制作一个测试程序，在 30 个不同的线程中以随机顺序调用所有函数 10000 次。

如果遇到死锁，可以使用 VS2010“并行堆栈”窗口。调试->Windows->并行堆栈
该窗口将显示所有堆栈，以便您可以找到死锁的方法。

我用来编写线程安全对象的简单策略：
线程安全对象在调用其公共方法时应该是安全的，因此在使用它时不会出现死锁。

因此，我们的想法是锁定所有访问对象数据的公共方法。
除此之外，您需要确保在类代码中永远不会调用公共方法。如果您需要使用其中一种公共方法，则将该方法设为私有，并用锁定然后调用该方法的公共方法包装该私有方法。

如果您想要更好的锁定粒度，您可以为每个拥有自己的锁的部分创建对象，然后像我建议的那样锁定它。然后使用封装将这些类合并为一个类。

例子：

class Blah {
  MyData data;
  Lock lock;
public:
  DataItem GetData(int index)
  { 
     ReadLock read(lock);
     return LocalGetData(index);
  }
  DataItem FindData(string key)
  {
     ReadLock read(lock);
     DataItem item;
     //find the item, can use LocalGetData() to get the item without deadlocking
     return item;

  }
  void PutData(DataItem item)
  {
    ReadLock write(lock); 
    //put item in database
  }

private:

  DataItem LocalGetData(int index)
  {
    return data[index];
  }
}

Best way to detect deadlocks (IMO) is to make a test program that calls all the functions in a random order in like 30 different threads 10000s of times.

If you get a deadlock you can use VS2010 "Parallel Stacks" window. Debug->Windows->Parallel Stacks
This window will show you all the stacks, so you can find the methods that are deadlocking.

A simple strategy I use to write thread-safe objects:
A thread safe object should be safe when its public methods are called, so you don't get deadlocks when it is used.

So, the idea is to just lock all the public methods that access the object's data.
Besides that you need to insure that within the class' code you never call a public method. If you need to use one of the public methods, then make that method private, and wrap the private method with a public method that locks and then calls it.

If you want better lock granularity you could just create objects for each part that has its own lock, and lock it like I suggested. Then use encapsulation to combine those classes to the one class.

Example:

class Blah {
  MyData data;
  Lock lock;
public:
  DataItem GetData(int index)
  { 
     ReadLock read(lock);
     return LocalGetData(index);
  }
  DataItem FindData(string key)
  {
     ReadLock read(lock);
     DataItem item;
     //find the item, can use LocalGetData() to get the item without deadlocking
     return item;

  }
  void PutData(DataItem item)
  {
    ReadLock write(lock); 
    //put item in database
  }

private:

  DataItem LocalGetData(int index)
  {
    return data[index];
  }
}

回复收藏 0 原文