线程锁定在Delphi XE5应用中

Question

I have some random locks of my app apparently without a reason.

As I found on the embarcadero website I found some documentation that maybe was some thread waiting to be ended.

When this happened I paused program execution from the IDE and went to the thread list.

This is what I got:

I'm quite stuck on this. How can I move further?

Answer 1

How can I move further?

If your application is built with debug info, then you can double-click any thread and you'll be taken to the line of source with the problem. You'll also get a call stack telling you the chain of calls leading to the 'current line' in each thread.

Of course in your case, the Wait Chain provides excellent clues where to start investigating the problem. This is where things get tricky, and only you will be able to debug further, because only you have all the source code.

But as an overview:

• A blocked thread's call-stack will lead to some form of wait function. Eg WaitForSingleObject or TEvent.Wait or TThread.WaitFor .
  • That thread won't continue executing until it's unblocked.
  • And you'd expect it to be unlocked from another thread.
• You need to look up the call-stack to find which high level object it's waiting for. Note it can be important to identify a specific instance and this is where it gets tricky.
• Once you've figured out exactly what is locked, you need to figure out why it hasn't been unlocked. (Note your screen shot makes reference to owner threads and processes which is very valuable information.)
  • You can double-click on other threads to examine where they are in their own calls stack. (Note the threads are paused by the debugger, but not blocked; so you can find yourself anywhere within the call-stack.)
  • You can also search other code that that interacts with the locked resource. (In fact, sometimes this is necessary particularly in cases of problem #3 below.)
• You'll have to examine the code to figure out why whatever resource is locked (and blocking other threads) hasn't been unlocked.

Likely problems include:

1. Owning thread is simply slow and will unlock the resource eventually.
2. Owning thread has a bug, and has entered an infinite loop preventing it from returning to unlock the resource.
3. Owning thread has a bug, and passed the code that should have unlocked the resource, but didn't. (A common cause of this is poor exception handling; use your try..finally 's correctly.)
4. Owning thread is itself blocked. If it's blocked by another blocked thread, you've encountered a particularly insidious kind of block referred to as a deadlock .

In all the above cases, you need to understand your bug so that you can fix it.