package org.h2.util;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.management.LockInfo;
import java.lang.management.ManagementFactory;
import java.lang.management.MonitorInfo;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Timer;
import java.util.TimerTask;
import org.h2.engine.SysProperties;
import org.h2.mvstore.db.MVTable;
public class ThreadDeadlockDetector {
private static final String INDENT = " ";
private static ThreadDeadlockDetector detector;
private final ThreadMXBean threadBean;
private ThreadDeadlockDetector() {
this.threadBean = ManagementFactory.getThreadMXBean();
Timer threadCheck = new Timer("ThreadDeadlockDetector", true);
threadCheck.schedule(new TimerTask() {
@Override
public void run() {
checkForDeadlocks();
}
}, 10, 10_000);
}
public static synchronized void init() {
if (detector == null) {
detector = new ThreadDeadlockDetector();
}
}
void checkForDeadlocks() {
long[] deadlockedThreadIds = threadBean.findDeadlockedThreads();
if (deadlockedThreadIds == null) {
return;
}
dumpThreadsAndLocks("ThreadDeadlockDetector - deadlock found :",
threadBean, deadlockedThreadIds, System.out);
}
public static void dumpAllThreadsAndLocks(String msg) {
dumpAllThreadsAndLocks(msg, System.out);
}
public static void dumpAllThreadsAndLocks(String msg, PrintStream out) {
final ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
final long[] allThreadIds = threadBean.getAllThreadIds();
dumpThreadsAndLocks(msg, threadBean, allThreadIds, out);
}
private static void dumpThreadsAndLocks(String msg, ThreadMXBean threadBean,
long[] threadIds, PrintStream out) {
final StringWriter stringWriter = new StringWriter();
final PrintWriter print = new PrintWriter(stringWriter);
print.println(msg);
final HashMap<Long, String> tableWaitingForLockMap;
final HashMap<Long, ArrayList<String>> tableExclusiveLocksMap;
final HashMap<Long, ArrayList<String>> tableSharedLocksMap;
if (SysProperties.THREAD_DEADLOCK_DETECTOR) {
tableWaitingForLockMap = MVTable.WAITING_FOR_LOCK
.getSnapshotOfAllThreads();
tableExclusiveLocksMap = MVTable.EXCLUSIVE_LOCKS
.getSnapshotOfAllThreads();
tableSharedLocksMap = MVTable.SHARED_LOCKS
.getSnapshotOfAllThreads();
} else {
tableWaitingForLockMap = new HashMap<>();
tableExclusiveLocksMap = new HashMap<>();
tableSharedLocksMap = new HashMap<>();
}
final ThreadInfo[] infos = threadBean.getThreadInfo(threadIds, true,
true);
for (ThreadInfo ti : infos) {
printThreadInfo(print, ti);
printLockInfo(print, ti.getLockedSynchronizers(),
tableWaitingForLockMap.get(ti.getThreadId()),
tableExclusiveLocksMap.get(ti.getThreadId()),
tableSharedLocksMap.get(ti.getThreadId()));
}
print.flush();
out.println(stringWriter.getBuffer());
out.flush();
}
private static void printThreadInfo(PrintWriter print, ThreadInfo ti) {
printThread(print, ti);
StackTraceElement[] stackTrace = ti.getStackTrace();
MonitorInfo[] monitors = ti.getLockedMonitors();
for (int i = 0; i < stackTrace.length; i++) {
StackTraceElement e = stackTrace[i];
print.println(INDENT + "at " + e.toString());
for (MonitorInfo mi : monitors) {
if (mi.getLockedStackDepth() == i) {
print.println(INDENT + " - locked " + mi);
}
}
}
print.println();
}
private static void printThread(PrintWriter print, ThreadInfo ti) {
print.print("\"" + ti.getThreadName() + "\"" + " Id="
+ ti.getThreadId() + " in " + ti.getThreadState());
if (ti.getLockName() != null) {
print.append(" on lock=").append(ti.getLockName());
}
if (ti.isSuspended()) {
print.append(" (suspended)");
}
if (ti.isInNative()) {
print.append(" (running in native)");
}
print.println();
if (ti.getLockOwnerName() != null) {
print.println(INDENT + " owned by " + ti.getLockOwnerName() + " Id="
+ ti.getLockOwnerId());
}
}
private static void printLockInfo(PrintWriter print, LockInfo[] locks,
String tableWaitingForLock,
ArrayList<String> tableExclusiveLocks,
ArrayList<String> tableSharedLocksMap) {
print.println(INDENT + "Locked synchronizers: count = " + locks.length);
for (LockInfo li : locks) {
print.println(INDENT + " - " + li);
}
if (tableWaitingForLock != null) {
print.println(INDENT + "Waiting for table: " + tableWaitingForLock);
}
if (tableExclusiveLocks != null) {
print.println(INDENT + "Exclusive table locks: count = " + tableExclusiveLocks.size());
for (String name : tableExclusiveLocks) {
print.println(INDENT + " - " + name);
}
}
if (tableSharedLocksMap != null) {
print.println(INDENT + "Shared table locks: count = " + tableSharedLocksMap.size());
for (String name : tableSharedLocksMap) {
print.println(INDENT + " - " + name);
}
}
print.println();
}
}