Examples with MonitorInfo java.lang.management.MonitorInfo used on opensource projects

Example 66 with MonitorInfo

use of java.lang.management.MonitorInfo in project hbase by apache.

the class TimedOutTestsListener method printThreadInfo.

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

Example 67 with MonitorInfo

use of java.lang.management.MonitorInfo in project tomcat by apache.

the class Diagnostics method getThreadDump.

/**
 * Formats the thread dump for one thread.
 *
 * @param ti the ThreadInfo describing the thread
 * @return the formatted thread dump
 */
private static String getThreadDump(ThreadInfo ti) {
    StringBuilder sb = new StringBuilder(getThreadDumpHeader(ti));
    for (LockInfo li : ti.getLockedSynchronizers()) {
        sb.append(INDENT2 + "locks " + li.toString() + CRLF);
    }
    boolean start = true;
    StackTraceElement[] stes = ti.getStackTrace();
    Object[] monitorDepths = new Object[stes.length];
    MonitorInfo[] mis = ti.getLockedMonitors();
    for (MonitorInfo monitorInfo : mis) {
        monitorDepths[monitorInfo.getLockedStackDepth()] = monitorInfo;
    }
    for (int i = 0; i < stes.length; i++) {
        StackTraceElement ste = stes[i];
        sb.append(INDENT2 + "at " + ste.toString() + CRLF);
        if (start) {
            if (ti.getLockName() != null) {
                sb.append(INDENT2 + "- waiting on (a " + ti.getLockName() + ")");
                if (ti.getLockOwnerName() != null) {
                    sb.append(" owned by " + ti.getLockOwnerName() + " Id=" + ti.getLockOwnerId());
                }
                sb.append(CRLF);
            }
            start = false;
        }
        if (monitorDepths[i] != null) {
            MonitorInfo mi = (MonitorInfo) monitorDepths[i];
            sb.append(INDENT2 + "- locked (a " + mi.toString() + ")" + " index " + mi.getLockedStackDepth() + " frame " + mi.getLockedStackFrame().toString());
            sb.append(CRLF);
        }
    }
    return sb.toString();
}

Example 68 with MonitorInfo

use of java.lang.management.MonitorInfo in project killbill by killbill.

the class GuicyKillbillTestSuiteWithEmbeddedDB method threadDump.

private void threadDump() {
    final ThreadInfo[] threads = ManagementFactory.getThreadMXBean().dumpAllThreads(true, true);
    final ByteArrayOutputStream out = new ByteArrayOutputStream();
    final PrintWriter writer = new PrintWriter(new OutputStreamWriter(out, Charset.forName("UTF-8")));
    for (int ti = threads.length - 1; ti >= 0; ti--) {
        final ThreadInfo t = threads[ti];
        writer.printf("\"%s\" id=%d state=%s", t.getThreadName(), t.getThreadId(), t.getThreadState());
        final LockInfo lock = t.getLockInfo();
        if (lock != null && t.getThreadState() != Thread.State.BLOCKED) {
            writer.printf("%n    - waiting on <0x%08x> (a %s)", lock.getIdentityHashCode(), lock.getClassName());
            writer.printf("%n    - locked <0x%08x> (a %s)", lock.getIdentityHashCode(), lock.getClassName());
        } else if (lock != null && t.getThreadState() == Thread.State.BLOCKED) {
            writer.printf("%n    - waiting to lock <0x%08x> (a %s)", lock.getIdentityHashCode(), lock.getClassName());
        }
        if (t.isSuspended()) {
            writer.print(" (suspended)");
        }
        if (t.isInNative()) {
            writer.print(" (running in native)");
        }
        writer.println();
        if (t.getLockOwnerName() != null) {
            writer.printf("     owned by %s id=%d%n", t.getLockOwnerName(), t.getLockOwnerId());
        }
        final StackTraceElement[] elements = t.getStackTrace();
        final MonitorInfo[] monitors = t.getLockedMonitors();
        for (int i = 0; i < elements.length; i++) {
            final StackTraceElement element = elements[i];
            writer.printf("    at %s%n", element);
            for (int j = 1; j < monitors.length; j++) {
                final MonitorInfo monitor = monitors[j];
                if (monitor.getLockedStackDepth() == i) {
                    writer.printf("      - locked %s%n", monitor);
                }
            }
        }
        writer.println();
        final LockInfo[] locks = t.getLockedSynchronizers();
        if (locks.length > 0) {
            writer.printf("    Locked synchronizers: count = %d%n", locks.length);
            for (LockInfo l : locks) {
                writer.printf("      - %s%n", l);
            }
            writer.println();
        }
    }
    writer.println();
    writer.flush();
    log.error("********************************************");
    log.error("*** TESTS HAVE FAILED - DUMPING THREADS ****");
    log.error("********************************************\n");
    log.error(out.toString());
    log.error("********************************************");
}

Example 69 with MonitorInfo

use of java.lang.management.MonitorInfo in project karaf by apache.

the class ThreadDumpProvider method getDumpThreadString.

protected String getDumpThreadString(ThreadInfo threadInfo) {
    StringBuilder sb = new StringBuilder();
    sb.append("\"").append(threadInfo.getThreadName()).append("\"").append(" Id=").append(threadInfo.getThreadId()).append(" ").append(threadInfo.getThreadState());
    if (threadInfo.getLockName() != null) {
        sb.append(" on ").append(threadInfo.getLockName());
    }
    if (threadInfo.getLockOwnerName() != null) {
        sb.append(" owned by \"").append(threadInfo.getLockOwnerName()).append("\" Id=").append(threadInfo.getLockOwnerId());
    }
    if (threadInfo.isSuspended()) {
        sb.append(" (suspended)");
    }
    if (threadInfo.isInNative()) {
        sb.append(" (in native)");
    }
    sb.append('\n');
    int i = 0;
    StackTraceElement[] stackTrace = threadInfo.getStackTrace();
    for (; i < stackTrace.length; i++) {
        StackTraceElement ste = stackTrace[i];
        sb.append("\tat ").append(ste.toString());
        sb.append('\n');
        if (i == 0 && threadInfo.getLockInfo() != null) {
            Thread.State ts = threadInfo.getThreadState();
            switch(ts) {
                case BLOCKED:
                    sb.append("\t-  blocked on ").append(threadInfo.getLockInfo());
                    sb.append('\n');
                    break;
                case WAITING:
                    sb.append("\t-  waiting on ").append(threadInfo.getLockInfo());
                    sb.append('\n');
                    break;
                case TIMED_WAITING:
                    sb.append("\t-  waiting on ").append(threadInfo.getLockInfo());
                    sb.append('\n');
                    break;
                default:
            }
        }
        for (MonitorInfo mi : threadInfo.getLockedMonitors()) {
            if (mi.getLockedStackDepth() == i) {
                sb.append("\t-  locked ").append(mi);
                sb.append('\n');
            }
        }
    }
    if (i < stackTrace.length) {
        sb.append("\t...");
        sb.append('\n');
    }
    LockInfo[] locks = threadInfo.getLockedSynchronizers();
    if (locks.length > 0) {
        sb.append("\n\tNumber of locked synchronizers = ").append(locks.length);
        sb.append('\n');
        for (LockInfo li : locks) {
            sb.append("\t- ").append(li);
            sb.append('\n');
        }
    }
    sb.append('\n');
    return sb.toString();
}

Example 70 with MonitorInfo

use of java.lang.management.MonitorInfo in project partyline by Commonjava.

the class ThreadDumper method dumpThreads.

public static void dumpThreads() {
    StringBuilder sb = new StringBuilder();
    ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
    ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(threadMXBean.getAllThreadIds(), 100);
    Stream.of(threadInfos).forEachOrdered((ti) -> {
        if (sb.length() > 0) {
            sb.append("\n\n");
        }
        sb.append(ti.getThreadName()).append("\n  State: ").append(ti.getThreadState()).append("\n  Lock Info: ").append(ti.getLockInfo()).append("\n  Monitors:");
        MonitorInfo[] monitors = ti.getLockedMonitors();
        if (monitors == null || monitors.length < 1) {
            sb.append("  -NONE-");
        } else {
            sb.append("\n  - ").append(join(monitors, "\n  - "));
        }
        sb.append("\n  Trace:\n    ").append(join(ti.getStackTrace(), "\n    "));
    });
    System.out.println(sb);
}