扩展我们的ThreadPoolExecutor线程池，让它在调度任务之前，先保存一下提交任务线程的堆栈信息
public class TraceThreadPoolExecutor extends ThreadPoolExecutor {
public TraceThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
public TraceThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
}
public TraceThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
}
@Override
public void execute(Runnable task) {
final long startTime = System.currentTimeMillis();
super.execute(wrap(task, clientTrace(), Thread.currentThread().getName(), startTime));
}
@Override
public Future<?> submit(Runnable task) {
final long startTime = System.currentTimeMillis();
return super.submit(wrap(task, clientTrace(), Thread.currentThread().getName(), startTime));
}
@Override
protected void beforeExecute(Thread t, Runnable r) {
System.out.println("准备执行：" + Thread.currentThread().getName());
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
System.out.println("执行完成：" + Thread.currentThread().getName());
}
@Override
protected void terminated() {
System.out.println("线程池退出");
}
private Exception clientTrace() {
return new Exception("Client stack trace ");
}
private Runnable wrap(final Runnable task, final Exception clientStack, final String clientThreadName, final long startTime) {
return () -> {
try {
final long queueDuration = System.currentTimeMillis() - startTime;
System.out.println("Task " + Thread.currentThread().getName() + " spent " + queueDuration + "ms in queue");
task.run();
} catch (Exception e) {
clientStack.printStackTrace();
throw e;
}
};
}
}
使用 Guava 中工具类 ThreadFactoryBuilder
public static void main(String[] args) {
int core = Runtime.getRuntime().availableProcessors();
int max = core * 2;
BlockingQueue<Runnable> blockingQueue = new LinkedBlockingQueue<>(1000);
final ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("Orders-%d").setDaemon(false).build();
TraceThreadPoolExecutor threadPool = new TraceThreadPoolExecutor(core, max, 10, TimeUnit.SECONDS, blockingQueue,
threadFactory, new CallerRunsPolicy());
for (int i = 0; i < 10; i++) {
threadPool.execute(() -> {
int a = new Random().nextInt(1000);
if (a > 500) {
a = 100/0;
}
System.out.println("====>"+ new Random().nextInt(1000));
});
}
try {
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
threadPool.shutdown();
}
对线程池中死锁检查
public static void main(String[] args) throws InterruptedException {
ThreadMXBean mbean = ManagementFactory.getThreadMXBean();
Runnable dlCheck = new Runnable() {
@Override
public void run() {
long[] threadIds = mbean.findDeadlockedThreads();
if (threadIds != null) {
ThreadInfo[] threadInfos = mbean.getThreadInfo(threadIds);
System.out.println("Detected deadlock threads:");
for (ThreadInfo threadInfo : threadInfos) {
System.out.println(threadInfo.getThreadName());
}
}
}
};
ScheduledExecutorService scheduler =Executors.newScheduledThreadPool(1);
// 稍等5秒，然后每10秒进行一次死锁扫描
scheduler.scheduleAtFixedRate(dlCheck, 5L, 10L, TimeUnit.SECONDS);
// 死锁样例代码…
}
