Re: About multithreading

Piotr Kobzda wrote:


To measure somehow this ambiguity in identity, I wrote this:

     Object o1 = new Object(), o2 = new Object();
     long count = 0;
     while(o2.hashCode() != o1.hashCode() && ++count != 0)
         o2 = new Object();
     System.out.printf("%s\n%s\n%d\n", o1, o2, count);

On my machine it prints out the following:

java.lang.Object@187aeca
java.lang.Object@187aeca
6241753

[ results vary depending on the JVM implementation and a heap size
related options ]

It proves to me that there is a real danger in having two distinct
objects with same identity-hash-code and class-name on same time.

Now I wonder why a lock object itself is not referenced (e.g. weakly) by
a LockInfo class?
The same question might be widened to a ThreadInfo and other ...Info
classes.

The JMX would be more powerful with such references present.

BTW -- In 1.6 during creation of a ThreadInfo true monitor/synchronizer
objects are passed by the JVM to this constructor:

     private ThreadInfo(Thread t, int state, Object lockObj, Thread
lockOwner,
                        long blockedCount, long blockedTime,
                        long waitedCount, long waitedTime,
                        StackTraceElement[] stackTrace,
                        Object[] monitors,
                        int[] stackDepths,
                        Object[] synchronizers)

So if for debugging purposes we are interested in a monitors (or any
synchronizers -- not a ReentrantLock only) lock owner detection, we can
create our own version of ThreadInfo class, which will assign true
object reference with a LockInfo (and MonitorInfo) instances it creates.
And than, after adding our modified ThreadInfo (possibly with a few
additional classed) as a first entry in the bootstrap classpath, the JVM
we will give us all information we need for certain locks identity.

Example code supporting this extended usage scenario is attached below.

It checks if a provided LockInfo implements the following simple interface:

     public interface LockReference {
         Object getLock();
     }

if so, it uses the result of getLock() in comparison with a lock
candidate. Otherwise, it prints a warning message (see sameIdentity()
implementation).

piotr

==== Locks16.java ====

import java.lang.management.*;
import java.util.*;

public class Locks16 {

     static final ThreadMXBean threadMXBean
             = ManagementFactory.getThreadMXBean();

     public static Thread monitorLockOwner(Object lock) {
         for(ThreadInfo ti :
             threadMXBean.getThreadInfo(
                     threadMXBean.getAllThreadIds(), true, false)) {
             for(MonitorInfo li : ti.getLockedMonitors())
                 if (sameIdentity(li, lock))
                     return threadForId(ti.getThreadId());
         }
         return null;
     }

     public static Thread synchronizerLockOwner(Object lock) {
         for(ThreadInfo ti :
             threadMXBean.getThreadInfo(
                     threadMXBean.getAllThreadIds(), false, true)) {
             for(LockInfo li : ti.getLockedSynchronizers())
                 if (sameIdentity(li, lock))
                     return threadForId(ti.getThreadId());
         }
         return null;
     }

     public static Thread[] blockedWaitingThreads(Object lock) {
         List<Thread> threads = new ArrayList<Thread>();
         for(ThreadInfo ti :
             threadMXBean.getThreadInfo(
                 threadMXBean.getAllThreadIds(), false, false)) {
             LockInfo li = ti.getLockInfo();
             if (li != null && sameIdentity(li, lock))
                 threads.add(threadForId(ti.getThreadId()));
         }
         return threads.toArray(new Thread[threads.size()]);
     }

     private static boolean sameIdentity(LockInfo li, Object lock) {
         if (li.getIdentityHashCode() == System.identityHashCode(lock)
                 && li.getClassName().equals(lock.getClass().getName())) {
             if (li instanceof LockReference)
                 return ((LockReference)li).getLock() == lock;
             System.err.println("#warning: possible " +
                     "ambiguity in detected lock " + lock + " identity");
             return true;
         }
         return false;
     }

     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;
     }

     /**
      * Test
      * @param args
      */
     public static void main(String[] args) throws Exception {
         final Object lock = new Object();

         Thread checker = new Thread() {
             public void run() {
                 while(true) {
                     System.out.println("lock owner: "
                             + monitorLockOwner(lock));
                     System.out.println("blocked threads: "
                             +
Arrays.toString(blockedWaitingThreads(lock)));
                     try {
                         Thread.sleep(1000);
                     } catch (InterruptedException ignore) {}
                 }
             }
         };
         checker.setDaemon(true);
         checker.start();

         Thread.sleep(2000);

         for(int i = 1; i <= 10; ++i) {
             Thread locker = new Thread("#" + i) {
                 public void run() {
                     try {
                         synchronized(lock) {
                             System.out.println(this + " entered monitor");
                             Thread.sleep(1000);
                         }
                     } catch (InterruptedException ignore) {
                     } finally {
                         System.out.println(this + " left monitor");
                     }
                 };
             };
             locker.setDaemon(true);
             locker.start();
         }

         Thread.sleep(12000);
     }

}