我的应用程序中的一个线程在下面的 lock 语句中被阻塞并导致死锁
void ExecuteCommand()
{
lock(this._lockinstance)
{
// do some operation
}
}
是否可以轻松识别当前持有锁的线程？.. 我的应用程序有超过 50 个线程，这使得使用 Visual Studio 遍历每个调用堆栈来定位持有锁的线程变得困难
【问题讨论】：
标签： c#
一些示例代码可以试用：
class Test {
private object locker = new object();
public void Run() {
lock (locker) { // <== breakpoint here
Console.WriteLine(System.Threading.Thread.CurrentThread.ManagedThreadId);
}
}
}
在指定的行上设置断点。当它中断时，使用 Debug + Windows + Memory + Memory 1. 右键单击窗口并选择“4-byte Integer”。在地址框中，键入 &locker。第二个字是拥有锁的线程的线程 ID。跳过 lock 语句以查看它的变化。
请注意，该数字是托管线程 ID，而不是您在“调试 + Windows + 线程”窗口中看到的操作系统线程 ID。这有点糟糕，你可能应该在你的程序中添加一些日志来转储 ManagedThreadId 的值，这样你就有办法将值与线程匹配。更新：在更高的 VS 版本中已修复，Debug > Windows > Threads 调试器窗口现在显示 ManagedThreadId。
【讨论】：
&locker 似乎不起作用。只是给出“无法评估表达式”。 locker 有效，但这不允许我看到您描述的线程 ID。 (VS2010)
最近我试图确定哪个函数持有锁，发现以下非常有用，并且在以前的任何地方都没有见过。我把它作为答案放在这里，以防其他人也觉得它有用。
之前发布的许多其他解决方案需要编写一个新类，然后将所有 lock(blah) 转换为 BetterLock(blah)，这需要大量的调试工作，并且您可能不希望在生产/交付版本你的代码。其他人则需要附加调试器，这会改变代码的时序并可能掩盖问题。
请尝试以下方法...
object obj = new object();
lock(obj)
{
// Do stuff
}
object _obj = new object();
object obj
{
get
{
System.Diagnostics.StackFrame frame = new System.Diagnostics.StackFrame(1);
System.Diagnostics.Trace.WriteLine(String.Format("Lock acquired by: {0} on thread {1}", frame.GetMethod().Name, System.Threading.Thread.CurrentThread.ManagedThreadId));
return _obj;
}
}
// Note that the code within lock(obj) and the lock itself remain unchanged.
lock(obj)
{
// Do stuff
}
通过将obj 公开为属性，至少是暂时的，通过非常 最少的代码更改，您可以确定哪个函数最后获得了锁以及在哪个线程上 - 只需查看跟踪输出最后一个条目。当然，您也可以输出任何其他可能对 getter 有用的信息。
不，这不会让您确定何时释放锁，但如果它及时释放，那么您实际上并没有首先遇到锁争用问题.
【讨论】：
"Attempting to acquire lock"。在高竞争下，跟踪中消息的顺序可能与线程获取锁的实际顺序不同。
您可以实现一个监视器包装器，在输入时保存堆栈跟踪和线程名称。
老办法：
private object myLock = new object();
...
lock(myLock)
{
DoSomething();
}
...
代码如下：
private SmartLock myLock = new SmartLock();
...
myLock.Lock( () =>
{
DoSomething();
}
);
...
来源：
public class SmartLock
{
private object LockObject = new object();
private string HoldingTrace = "";
private static int WARN_TIMEOUT_MS = 5000; //5 secs
public void Lock(Action action)
{
try
{
Enter();
action.Invoke();
}
catch (Exception ex)
{
Globals.Error("SmartLock Lock action", ex);
}
finally
{
Exit();
}
}
private void Enter()
{
try
{
bool locked = false;
int timeoutMS = 0;
while (!locked)
{
//keep trying to get the lock, and warn if not accessible after timeout
locked = Monitor.TryEnter(LockObject, WARN_TIMEOUT_MS);
if (!locked)
{
timeoutMS += WARN_TIMEOUT_MS;
Globals.Warn("Lock held: " + (timeoutMS / 1000) + " secs by " + HoldingTrace + " requested by " + GetStackTrace());
}
}
//save a stack trace for the code that is holding the lock
HoldingTrace = GetStackTrace();
}
catch (Exception ex)
{
Globals.Error("SmartLock Enter", ex);
}
}
private string GetStackTrace()
{
StackTrace trace = new StackTrace();
string threadID = Thread.CurrentThread.Name ?? "";
return "[" + threadID + "]" + trace.ToString().Replace('\n', '|').Replace("\r", "");
}
private void Exit()
{
try
{
Monitor.Exit(LockObject);
HoldingTrace = "";
}
catch (Exception ex)
{
Globals.Error("SmartLock Exit", ex);
}
}
}
【讨论】：
是的，您可以在 VS 中使用“线程”视图。在应用程序中的任意位置中断（或单击“全部中断”按钮），然后您可以选择每个线程并查看谁拥有锁定（如果有人）。
要添加它，请转到调试 > Windows > 线程 (Ctrl+D,T)
【讨论】：
旧帖子已过时。
但我想我可能会给出一个我认为对于尝试追踪死锁和其他锁定问题非常有用的解决方案。
我为我的锁使用一次性类 - 我喜欢 Monitor，但可以使用任何锁定机制。
public class MonitorLock : IDisposable
{
public static MonitorLock CreateLock(object value)
{
return new MonitorLock(value);
}
private readonly object _l;
protected MonitorLock(object l)
{
_l = l;
Console.WriteLine("Lock {0} attempt by {1}", _l, Thread.CurrentThread.ManagedThreadId);
Monitor.Enter(_l);
Console.WriteLine("Lock {0} held by {1}" , _l, Thread.CurrentThread.ManagedThreadId);
}
public void Dispose()
{
Monitor.Exit(_l);
Console.WriteLine("Lock {0} released by {1}", _l, Thread.CurrentThread.ManagedThreadId);
}
}
我使用了一个带有名称的锁对象，这样我就可以清楚地知道我正在尝试获取哪个锁。
public class LockObject
{
public string Name { get; set; }
public LockObject(string name)
{
Name = name;
}
public override string ToString()
{
return Name;
}
}
最后创建一个锁对象，然后在一个 using 块中持有该对象。
//create an object to lock on
private readonly object _requestLock = new LockObject("_requestLock");
using (MonitorLock.CreateLock(_requestLock))
{
//do some work
}
输出应该类似于
Lock _requestLock attempt by 92
Lock _requestLock held by 92
Lock _requestLock attempt by 19
Lock _requestLock released by 92
Lock _requestLock held by 19
Lock _requestLock released by 19
希望有人觉得这很有用:)
【讨论】：
MonitorLock 设置为struct。编译器足够聪明，不会在 using 块中使用时将结构装箱，并且您将为每个占用的锁节省分配空间。
Monitor.IsEntered 的可重入代码以获得更多有用的跟踪。
http://mse.codeplex.com/ 或 http://www.microsoft.com/downloadS/details.aspx?FamilyID=80cf81f7-d710-47e3-8b95-5a6555a230c2&displaylang=en 的托管堆栈资源管理器在这种情况下非常出色。
它连接到正在运行的托管代码（需要适当的权限），包括实时代码，并获取正在运行的线程列表。您可以双击它们中的任何一个，或者（在这种情况下更有用）选择批次并按 Enter 以快速相对非侵入性地进行（显然它会消耗资源，但它会尽可能快地进出) 转储不同线程的当前堆栈。非常适合发现死锁、无限循环、近乎无限循环（当您的应用程序意外地依赖于天文学家对地球将持续多长时间才能完成的时候感到悲观）和其他此类情况。
【讨论】：