Question

I’ve been caught by yet another deadlock in our Java application and started thinking about how to detect potential deadlocks in the future. I had an idea of how to do this, but it seems almost too simple.

I’d like to hear people’s views on it.

I plan to run our application for several hours in our test environment, using a typical data set.

I think it would be possible to perform bytecode manipulation on our application such that, whenever it takes a lock (e.g. entering a synchronized block), details of the lock are added to a ThreadLocal list.

I could write an algorithm that, at some later point, compares the lists for all threads and checks if any contain the same pair of locks in opposite order – this would be reported as a deadlock possibility. Again, I would use bytecode manipulation to add this periodic check to my application.

So my question is this: is this idea (a) original and (b) viable?

Answer 1

This is something that we talked about when I took a course in concurrency. I’m not sure if your implementation is original, but the concept of analysis to determine potential deadlock is not unique. There are dynamic analysis tools for Java, such as JCarder. There is also research into some analysis that can be done statically.

Admittedly, it’s been a couple of years since I’ve looked around. I don’t think JCarder was the specific tool we talked about (at least, the name doesn’t sound familiar, but I couldn’t find anything else). But the point is that analysis to detect deadlock isn’t an original concept, and I’d start by looking at research that has produced usable tools as a starting point – I would suspect that the algorithms, if not the implementation, are generally available.