package jdk_concurrent;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class GetExceptionThreadPool {

	public static void main(String[] args) {
		getExp2();
	}

	private static void getExp() {
		ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 0L, TimeUnit.SECONDS,
				new SynchronousQueue<Runnable>());
		for (int i = 0; i < 5; i++) {
			// poolExecutor.execute(new DivTask(100, i));
			// submit()有时会丢失异常堆栈
			poolExecutor.submit(new DivTask(100, i));
		}
	}

	
	private static void getExp2() {
		ThreadPoolExecutor poolExecutor = new TraceThreadPoolExecutor(0, Integer.MAX_VALUE, 0L, TimeUnit.SECONDS,
				new SynchronousQueue<Runnable>());
		for (int i = 0; i < 5; i++) {
			// poolExecutor.execute(new DivTask(100, i));
			// submit()有时会丢失异常堆栈
			poolExecutor.submit(new DivTask(100, i));
		}
	}

	public static class DivTask implements Runnable {
		int a, b;

		public DivTask(int a, int b) {
			super();
			this.a = a;
			this.b = b;
		}

		@Override
		public void run() {
			double re = a / b;
			System.out.println(re);
		}
	}

	// 自定义线程池追踪异常堆栈
	public static class TraceThreadPoolExecutor extends ThreadPoolExecutor {

		public TraceThreadPoolExecutor(int coreSize, int maximumSize, long keepAliveTime, TimeUnit unit,
				BlockingQueue<Runnable> workQueue) {
			super(coreSize, maximumSize, keepAliveTime, unit, workQueue);
		}

		@Override
		public void execute(Runnable task) {
			super.execute(wrap(task, clientTrace(), Thread.currentThread().getName()));
		}

		@Override
		public Future<?> submit(Runnable task) {
			return super.submit(wrap(task, clientTrace(), Thread.currentThread().getName()));
		}

		private Exception clientTrace() {
			return new Exception("Client stack trace");
		}

		private Runnable wrap(final Runnable task, final Exception clientStack, String clientThreadName) {
			return new Runnable() {
				@Override
				public void run() {
					try {
						task.run();
					} catch (Exception e) {
						clientStack.printStackTrace();
						e.printStackTrace();
						throw e;
					}
				}
			};
		}

	}

}