Re: About multithreading
Piotr Kobzda wrote:
Thomas Hawtin wrote:
I'd like to know if there is any way to know which execution thread
holds a lock. That is, I would like to know, before a block
synchronized(o), if any other thread holds the lock to o (for
debugging, for example, because I think that no other thread should
have the lock at that moment). I think it's not possible, not even with
the new ReentrantLocks, but just in case you may have any suggestion to
debug these kind of things...
In 1.6 you can use JMX.
Unfortunately, even in 1.6 you can't always guess which execution thread
holds a lock. The problem is in lock object identity offered with JMX
management classes. LockInfo can tell us only what is the
identity-hash-code and a class name of locked monitor/synchronizer
object, not a lock object itself. As the result it is not always safe
to say that a given lock object is actually the same object as the one
identified by LockInfo.
One workaround for mentioned possible ambiguity in lock object identity
is attached below (not tested intensively!).
It tries to acquire a lock on a given object, and than, in a case when a
lock acquiring thread is blocked, makes a use of JMX's ThreadInfo to
find a thread which holds this lock.
It's currently implemented to detect monitor locks only (which seems to
work fine in both 1.5 and 1.6) -- synchronizers locks detection
(supported only with JMX in 1.6) is left for the reader. :)
piotr
==== Locks.java ====
import java.lang.management.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.locks.*;
public class Locks {
static final ThreadMXBean threadMXBean
= ManagementFactory.getThreadMXBean();
private static ExecutorService taskExecutor
= Executors.newCachedThreadPool(new ThreadFactory() {
AtomicLong count = new AtomicLong();
public Thread newThread(Runnable r) {
Thread t = new Thread(r,
"locks-pool-thread-"
+ count.incrementAndGet());
t.setDaemon(true);
return t;
}
});
public static Thread lockOwner(final Object lock) {
final ReentrantLock taskLock = new ReentrantLock();
final Condition taskSync = taskLock.newCondition();
class Task implements Runnable {
volatile long threadId = -1;
public void run() {
taskLock.lock();
try {
threadId = Thread.currentThread().getId();
taskSync.signal();
} finally {
taskLock.unlock();
}
// acquire a lock
synchronized (lock) {}
}
};
taskLock.lock();
try {
Task task = new Task();
Future<?> future = taskExecutor.submit(task);
while (task.threadId == -1 && !future.isDone()) {
try {
taskSync.await();
} catch (InterruptedException ignore) {}
}
while(task.threadId != -1 && !future.isDone()) {
ThreadInfo ti = threadMXBean
.getThreadInfo(task.threadId);
if (ti == null)
break; // task died
long lockOwnerId = ti.getLockOwnerId();
if (lockOwnerId != -1) {
future.cancel(true);
return threadForId(lockOwnerId);
}
}
} finally {
taskLock.unlock();
}
return null;
}
private static Thread threadForId(long threadId) {
Thread[] threads = new Thread[Thread.activeCount()];
Thread.enumerate(threads);
for(Thread t : threads)
if (t != null && t.getId() == threadId)
return t;
return null;
}
}