FULL PRODUCT VERSION :
Java 1.5.0_06 with Sun Microsystems Inc. Java HotSpot(TM) Client VM mixed mode

ADDITIONAL OS VERSION INFORMATION :
Windows XP

A DESCRIPTION OF THE PROBLEM :
I would like to use findMonitorDeadlockedThreads() to determine when a thread lock occurs in my application. I can get this working fine for generic thread deadlocks, but I can't get this working if the deadlock is between the Main thread and the Event Dispatch thread. This is the most common deadlock scenario for Java apps, so it is surprising that the management API is not robust.

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :


  To reproduce:
ThreadMonitor.runme("mylogfile.txt");

Create a generic deadlock
ThreadMonitor.testDeadLock(); // works okay

Create a swing deadlock:
ThreadMonitor.runme("mylogfile.txt");
StrangeProblem(); // doesn't work

No log file is written.



EXPECTED VERSUS ACTUAL BEHAVIOR :
EXPECTED -
I would expect fMBean.findMonitorDeadlockedThreads() to be robust to AWT-Main deadlocks
ACTUAL -
The thread that calls findMonitorDeadlockedThreads() hangs inside this method call.

REPRODUCIBILITY :
This bug can be reproduced always.

---------- BEGIN SOURCE ----------
>>>>>>>>>>>>>>>>>>>>>>>>>.
import java.lang.management.*;
import java.util.*;
import java.io.FileWriter;
import java.io.BufferedWriter;

public class ThreadMonitor extends Thread {
    private static final int FREQUENCY = 5000;  // every 5 seconds
    private Set fDeadlockedThreads = new HashSet();
    private String fFilename;
   // private final Timer fThreadCheck = new Timer("Thread Monitor", true);


    public static void runme(String filename) {
        ThreadMonitor t = new ThreadMonitor(filename);
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();
    }
    private ThreadMonitor(String filename) {
        fFilename = filename;
    }

    /**
     * Monitor deadlocks.
     */
    public void run() {

        ThreadMXBean fMBean = ManagementFactory.getThreadMXBean();
        boolean flag = false;
        while(!flag) {
                BufferedWriter out = null;
                try {
                                //Thread.sleep(5000);


                    //System.out.println("checking...");
                    long[] ids = fMBean.findMonitorDeadlockedThreads();
                    if (ids != null && ids.length > 0) {
                        //System.out.println("Thread deadlock detected, see log: " + fFilename);
                        FileWriter fw = new FileWriter(fFilename);
                        out = new BufferedWriter(fw);
                        for (int n = 0; n < ids.length; n++) {
                            ThreadInfo ti = fMBean.getThreadInfo(ids[n], 20);
                            if (!fDeadlockedThreads.contains(new Long(ids[n]))) {
                                StackTraceElement el[] = ti.getStackTrace();
                                if (out!=null) {
                                    out.write("Thread lock for: " + ti.getThreadName());
                                    out.newLine();
                                    for(int i = 0; i<el.length; i++) {
                                        out.write(el[i].getClassName()+ "."+el[i].getMethodName());
                                        out.newLine();
                                    }
                                    out.write("");
                                    out.newLine();
                                }
                                fDeadlockedThreads.add(new Long(ids[n]));
                            }
                        }
                        out.close();
                        flag = true;

                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }
        }
    }


    // got this from internet
    public static void testDeadLock() {
        // deadlock with three locks
        Object lock1 = new String("lock1");
        Object lock2 = new String("lock2");
        Object lock3 = new String("lock3");

        new DeadlockingThread("t1", lock1, lock2);
        new DeadlockingThread("t2", lock2, lock3);
        new DeadlockingThread("t3", lock3, lock1);
    }

    private static class DeadlockingThread extends Thread {
        private final Object lock1;
        private final Object lock2;

        public DeadlockingThread(String name, Object lock1, Object lock2) {
            super(name);
            this.lock1 = lock1;
            this.lock2 = lock2;
            start();
        }
        public void run() {
            while (true) {
                f();
            }
        }
        private void f() {
            synchronized (lock1) {
                g();
            }
        }
        private void g() {
            synchronized (lock2) {
                // do some work...
                for (int i = 0; i < 1000 * 1000; i++) ;
            }
        }
    }
}


>>>>>>>>>>>>>>>>>>>>>>>>.
import javax.swing.*;
import java.awt.*;

public class StrangeProblem extends JFrame {
  static {
    new StrangeProblem();
  }

  private static void staticMethod() {
    System.out.println("This is never reached");
  }

  private StrangeProblem() {
    getContentPane().add(new MyJDesktopPane());
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setSize(300, 300);
    setVisible(true);
    // If commented out, program works fine, otherwise it hangs
    new JInternalFrame();
  }

  private class MyJDesktopPane extends JDesktopPane {
    protected void paintComponent(Graphics g) {
      super.paintComponent(g);
      System.out.println("We will now call the static method...");
      staticMethod();
      System.out.println("Static method was called.");
    }
  }

  public static void main(String[] args) {
  }
}

---------- END SOURCE ----------