java死锁检测

首先我们看看mina里面死锁的检测方法：

// private void checkDeadLock() {

//        // Only read / write / connect / write future can cause dead lock. 

//        if (!(this instanceof CloseFuture || this instanceof WriteFuture ||

//              this instanceof ReadFuture || this instanceof ConnectFuture)) {

//            return;

//        }

//        

//        // Get the current thread stackTrace. 

//        // Using Thread.currentThread().getStackTrace() is the best solution,

//        // even if slightly less efficient than doing a new Exception().getStackTrace(),

//        // as internally, it does exactly the same thing. The advantage of using

//        // this solution is that we may benefit some improvement with some

//        // future versions of Java.

//        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();

//

//        // Simple and quick check.

//        for (StackTraceElement s: stackTrace) {

//            if (AbstractPollingIoProcessor.class.getName().equals(s.getClassName())) {

//                IllegalStateException e = new IllegalStateException( "t" );

//                e.getStackTrace();

//                throw new IllegalStateException(

//                    "DEAD LOCK: " + IoFuture.class.getSimpleName() +

//                    ".await() was invoked from an I/O processor thread.  " +

//                    "Please use " + IoFutureListener.class.getSimpleName() +

//                    " or configure a proper thread model alternatively.");

//            }

//        }

//

//        // And then more precisely.

//        for (StackTraceElement s: stackTrace) {

//            try {

//                Class<?> cls = DefaultIoFuture.class.getClassLoader().loadClass(s.getClassName());

//                if (IoProcessor.class.isAssignableFrom(cls)) {

//                    throw new IllegalStateException(

//                        "DEAD LOCK: " + IoFuture.class.getSimpleName() +

//                        ".await() was invoked from an I/O processor thread.  " +

//                        "Please use " + IoFutureListener.class.getSimpleName() +

//                        " or configure a proper thread model alternatively.");

//                }

//            } catch (Exception cnfe) {

//                // Ignore

//            }

//        }

//    }

}

同理：

DeadlockHandler接口 

package handler;

import java.lang.management.ThreadInfo;

public interface DeadlockHandler {

public void handleDeadlock(final ThreadInfo[] deadlockedThreads);

}

DeadlockConsoleHandler 实现 DeadlockHandler接口

package handler;

import java.lang.management.ThreadInfo;

public class DeadlockConsoleHandler implements DeadlockHandler {

@Override
public void handleDeadlock(ThreadInfo[] deadlockedThreads) {
if (deadlockedThreads != null) {
System.err.println("Deadlock detected!");
for (ThreadInfo threadInfo : deadlockedThreads) {
if (threadInfo != null) {
for (Thread thread : Thread.getAllStackTraces().keySet()) {
if (thread.getId() == threadInfo.getThreadId()) {
System.err.println(threadInfo.toString().trim());
for (StackTraceElement ste : thread.getStackTrace()) {
System.err.println("t" + ste.toString().trim());
}
}
}
}
}
}
}

}

死锁检测类：DeadlockDetector

package detector;

import handler.DeadlockHandler;

import java.lang.management.ManagementFactory;

import java.lang.management.ThreadInfo;

import java.lang.management.ThreadMXBean;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

public class DeadlockDetector {

private final DeadlockHandler deadlockHandler;
private final long period;
private final TimeUnit timeUnit;
private final ThreadMXBean mBean = ManagementFactory.getThreadMXBean();

private final ScheduledExecutorService scheduler =
Executors.newScheduledThreadPool(1);

public DeadlockDetector(final DeadlockHandler deadlockHandler, final long period, final TimeUnit timeUnit) {
this.deadlockHandler = deadlockHandler;
this.period = period;
this.timeUnit = timeUnit;
}

final Runnable deadlockCheck = new Runnable () {
@Override
public void run() {
long[] deadlockedThreadIds = DeadlockDetector.this.mBean.findDeadlockedThreads();
if (deadlockedThreadIds != null) {
ThreadInfo[] threadInfos = DeadlockDetector.this.mBean.getThreadInfo(deadlockedThreadIds);
DeadlockDetector.this.deadlockHandler.handleDeadlock(threadInfos);
}
}
};

public void start() {
this.scheduler.scheduleAtFixedRate(this.deadlockCheck, this.period, this.period, this.timeUnit);
}

}

Main 类：

package main;

import handler.DeadlockConsoleHandler;

import java.util.concurrent.TimeUnit;

import detector.DeadlockDetector;

public class Main {

public static void main(String[] args) {
DeadlockDetector deadlockDetector = new DeadlockDetector(new DeadlockConsoleHandler(), 5, TimeUnit.SECONDS);
deadlockDetector.start();

runThread();
}

public static void runThread() {
final Object lock1 = new Object();
final Object lock2 = new Object();

Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock1) {
System.out.println("Thread1 acquired lock1");
try {
TimeUnit.MICROSECONDS.sleep(1000);
} catch (InterruptedException e) {

}
synchronized (lock2) {
System.out.println("Thread2 acquired lock2");
}
}
}
});

Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock2) {
System.out.println("Thread2 acquired lock2");
try {
TimeUnit.MICROSECONDS.sleep(1000);
} catch (InterruptedException e) {

}
synchronized (lock1) {
System.out.println("Thread2 acquired lock1");
}
}
}
});

thread1.start();
thread2.start();

System.out.println(thread1.getStackTrace());

}

}