Java MonitorInfo类代码示例

import java.lang.management.MonitorInfo; //导入依赖的package包/类
private static StringBuilder printThreadInfo(ThreadInfo ti, StringBuilder sb) {
    // print thread information
    printThread(ti, sb);

    // print stack trace with locks
    StackTraceElement[] stacktrace = ti.getStackTrace();
    MonitorInfo[] monitors = ti.getLockedMonitors();
    for (int i = 0; i < stacktrace.length; i++) {
        StackTraceElement ste = stacktrace[i];
        sb.append("\t at " + ste.toString()).append("\n");
        for (MonitorInfo mi : monitors) {
            if (mi.getLockedStackDepth() == i) {
                sb.append("\t  - locked " + mi).append("\n");
            }
        }
    }
    sb.append("\n");
    return sb;
}
 

import java.lang.management.MonitorInfo; //导入依赖的package包/类
private void printThreadInfo(ThreadInfo ti, PrintStream out) {
   printThread(ti, out);

   // print stack trace with locks
   StackTraceElement[] stacktrace = ti.getStackTrace();
   MonitorInfo[] monitors = ti.getLockedMonitors();
   for (int i = 0; i < stacktrace.length; i++) {
       StackTraceElement ste = stacktrace[i];
       out.println(INDENT + "at " + ste.toString()); // NOI18N
       for (MonitorInfo mi : monitors) {
           if (mi.getLockedStackDepth() == i) {
               out.println(INDENT + "  - locked " + mi); // NOI18N
           }
       }
   }
   out.println();
}
 

import java.lang.management.MonitorInfo; //导入依赖的package包/类
private static void printThreadInfo(ThreadInfo ti, PrintWriter out) {
  // print thread information
  printThread(ti, out);

  // print stack trace with locks
  StackTraceElement[] stacktrace = ti.getStackTrace();
  MonitorInfo[] monitors = ti.getLockedMonitors();
  for (int i = 0; i < stacktrace.length; i++) {
    StackTraceElement ste = stacktrace[i];
    out.println(INDENT + "at " + ste.toString());
    for (MonitorInfo mi : monitors) {
      if (mi.getLockedStackDepth() == i) {
        out.println(INDENT + "  - locked " + mi);
      }
    }
  }
  out.println();
}
 

import java.lang.management.MonitorInfo; //导入依赖的package包/类
private void printThreadInfo(ThreadInfo ti) {
   // print thread information
   printThread(ti);

   // print stack trace with locks
   StackTraceElement[] stacktrace = ti.getStackTrace();
   MonitorInfo[] monitors = ti.getLockedMonitors();
   for (int i = 0; i < stacktrace.length; i++) {
       StackTraceElement ste = stacktrace[i];
       System.out.println(INDENT + "at " + ste.toString());
       for (MonitorInfo mi : monitors) {
           if (mi.getLockedStackDepth() == i) {
               System.out.println(INDENT + "  - locked " + mi);
           }
       }
   }
   System.out.println();
}
 

import java.lang.management.MonitorInfo; //导入依赖的package包/类
public static boolean isMonitorLockHeldByThread(Object o, Thread t) {
    int oihc = System.identityHashCode(o);
    ThreadMXBean tmxbean = ManagementFactory.getThreadMXBean();
    ThreadInfo[] tinfos = tmxbean.dumpAllThreads(true, false);

    for (ThreadInfo ti : tinfos) {
        if (!(t != null && t.getId() != ti.getThreadId())) {
            for (MonitorInfo mi : ti.getLockedMonitors()) {
                if (mi.getIdentityHashCode() == oihc) {
                    return true;
                }
            }
        }
    }
    return false;
}
 

import java.lang.management.MonitorInfo; //导入依赖的package包/类
/**
 * We cannot simply call getLockedMonitors because it is not guaranteed to
 * return the locks in the correct order.
 */
private static void generateOrdering(final List<String> lockOrder,
        ThreadInfo info) {
    final MonitorInfo[] lockedMonitors = info.getLockedMonitors();
    Arrays.sort(lockedMonitors, new Comparator<MonitorInfo>() {
        @Override
        public int compare(MonitorInfo a, MonitorInfo b) {
            return b.getLockedStackDepth() - a.getLockedStackDepth();
        }
    });
    for (MonitorInfo mi : lockedMonitors) {
        String lockName = getObjectName(mi);
        if (lockName.equals("sun.misc.Launcher$AppClassLoader")) {
            // ignore, it shows up everywhere
            continue;
        }
        // Ignore locks which are locked multiple times in
        // succession - Java locks are recursive.
        if (!lockOrder.contains(lockName)) {
            lockOrder.add(lockName);
        }
    }
}
 

import java.lang.management.MonitorInfo; //导入依赖的package包/类
private void printThreadInfo(ThreadInfo ti, StringBuilder dump) {
   // print thread information
   printThread(ti, dump);

   // print stack trace with locks
   StackTraceElement[] stacktrace = ti.getStackTrace();
   MonitorInfo[] monitors = ti.getLockedMonitors();
   for (int i = 0; i < stacktrace.length; i++) {
       StackTraceElement ste = stacktrace[i];
       dump.append(INDENT + "at " + ste.toString());
       dump.append("\n");
       for (int j = 1; j < monitors.length; j++) {
           MonitorInfo mi = monitors[j];
           if (mi.getLockedStackDepth() == i) {
               dump.append(INDENT + "  - locked " + mi);
               dump.append("\n");
           }
       }
   }
   dump.append("\n");
}
 

import java.lang.management.MonitorInfo; //导入依赖的package包/类
private void printThreadInfo(ThreadInfo threadInfo) {
    printThread(threadInfo);
    this.sb.append(INDENT).append(threadInfo.toString()).append("\n");
    StackTraceElement[] stacktrace = threadInfo.getStackTrace();
    MonitorInfo[] monitors = threadInfo.getLockedMonitors();

    for (int i = 0; i < stacktrace.length; i++) {
        StackTraceElement ste = stacktrace[i];
        this.sb.append(INDENT).append("at ").append(ste.toString()).append("\n");
        for (MonitorInfo mi : monitors) {
            if (mi.getLockedStackDepth() == i) {
                this.sb.append(INDENT).append("  - locked ").append(mi).append("\n");
            }
        }
    }
}
 

import java.lang.management.MonitorInfo; //导入依赖的package包/类
private static void printThreadInfo(ThreadInfo ti, StringBuilder sb) {
    // print thread information
    printThread(ti, sb);

    // print stack trace with locks
    StackTraceElement[] stacktrace = ti.getStackTrace();
    MonitorInfo[] monitors = ti.getLockedMonitors();
    for (int i = 0; i < stacktrace.length; i++) {
        StackTraceElement ste = stacktrace[i];
        sb.append(INDENT);
        sb.append("at ");
        sb.append(ste.toString());
        sb.append(System.getProperty("line.separator"));
        for (MonitorInfo mi : monitors) {
            if (mi.getLockedStackDepth() == i) {
                sb.append(INDENT);
                sb.append("  - locked ");
                sb.append(mi);
                sb.append(System.getProperty("line.separator"));
            }
        }
    }
    sb.append(System.getProperty("line.separator"));
}
 

import java.lang.management.MonitorInfo; //导入依赖的package包/类
private void printThreadInfo(ThreadInfo ti, StringBuilder dump) {
    // print thread information
    printThread(ti, dump);

    // print stack trace with locks
    StackTraceElement[] stacktrace = ti.getStackTrace();
    MonitorInfo[] monitors = ti.getLockedMonitors();
    for (int i = 0; i < stacktrace.length; i++) {
        StackTraceElement ste = stacktrace[i];
        dump.append(TAB).append("at ").append(ste.toString()).append('\n');
        for (MonitorInfo mi : monitors) {
            if (mi.getLockedStackDepth() == i) {
                dump.append(TAB).append("  - locked ").append(mi).append('\n');
            }
        }
    }
    dump.append("");
}
 

import java.lang.management.MonitorInfo; //导入依赖的package包/类
private static void dumpThread(ThreadInfo thread, Logger log)
{
    log.log( Level.SEVERE, "------------------------------" );
    //
    log.log( Level.SEVERE, "Current Thread: " + thread.getThreadName() );
    log.log( Level.SEVERE, "\tPID: " + thread.getThreadId()
            + " | Suspended: " + thread.isSuspended()
            + " | Native: " + thread.isInNative()
            + " | State: " + thread.getThreadState() );
    if ( thread.getLockedMonitors().length != 0 )
    {
        log.log( Level.SEVERE, "\tThread is waiting on monitor(s):" );
        for ( MonitorInfo monitor : thread.getLockedMonitors() )
        {
            log.log( Level.SEVERE, "\t\tLocked on:" + monitor.getLockedStackFrame() );
        }
    }
    log.log( Level.SEVERE, "\tStack:" );
    //
    for ( StackTraceElement stack : thread.getStackTrace() )
    {
        log.log( Level.SEVERE, "\t\t" + stack );
    }
}
 

import java.lang.management.MonitorInfo; //导入依赖的package包/类
private static void setMonitorInfo(TThreadDump threadDump, ThreadInfo threadInfo) {
    MonitorInfo[] monitorInfos = threadInfo.getLockedMonitors();
    if (monitorInfos != null) {
        for (MonitorInfo each : monitorInfos) {
            if (each == null) {
                continue;
            }
            TMonitorInfo tMonitorInfo = new TMonitorInfo();

            tMonitorInfo.setStackDepth(each.getLockedStackDepth());
            tMonitorInfo.setStackFrame(each.getLockedStackFrame().toString());

            threadDump.addToLockedMonitors(tMonitorInfo);
        }
    } else {
        threadDump.setLockedMonitors(Collections.<TMonitorInfo>emptyList());
    }
}
 

import java.lang.management.MonitorInfo; //导入依赖的package包/类
@Override
int outputMonitors(ThreadInfo info, int stack_depth, int monitor_pointer, StringBuffer buffer) {
    MonitorInfo[] locked_monitors = info.getLockedMonitors();
    boolean check_next_monitor;
    do
    {
        check_next_monitor = false;
        if (monitor_pointer < locked_monitors.length)
        {
            MonitorInfo monitor_info = locked_monitors[monitor_pointer];
            if (monitor_info.getLockedStackDepth() == stack_depth)
            {
                formatLock(monitor_info, "locked", buffer);
                buffer.append("\n");
                monitor_pointer++;
                check_next_monitor = true;
            }
        }
    } while (check_next_monitor);

    return monitor_pointer;
}
 

import java.lang.management.MonitorInfo; //导入依赖的package包/类
private static void printMonitorInfo(ThreadInfo ti, MonitorInfo[] monitors, StringBuilder sb) {
    sb.append("\tLocked monitors: count = " + monitors.length).append("\n");
    for (MonitorInfo mi : monitors) {
        sb.append("\t  - " + mi + " locked at ").append("\n");
        sb.append("\t      " + mi.getLockedStackDepth() + " "
                + mi.getLockedStackFrame()).append("\n");
    }
}