起因是公司有一個定時任務，對於幾千的VPN，做一個埠對映，去取得對方客戶的硬體資訊，做一個監控。

但是部分VPN會連線不通，等待的時間又過長，所以設計這麼一個執行緒池。

原貼提供了一個執行緒超時終止的實現方式，我再在這個基礎上，整理成一個執行緒池。

首先是執行緒超時終止

import java.util.concurrent.Callable;

public class CallableImpl implements Callable<String> {
	private static final String CORRECT_KEY = "OK";
	private String key = "";

	public CallableImpl(String key) {
		this.key = key;
	}

	public String call() {
		// TODO:真正的業務邏輯
		if (CORRECT_KEY.equals(this.getKey())) {
			return "SUCCESS";
		} else {
			try {
				Thread.sleep(5000); // 阻塞。設定5秒超時，為了Future丟擲TimeoutException
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			return "FAIL";
		}
	}

	public String getKey() {
		return key;
	}

	public void setKey(String key) {
		this.key = key;
	}
}
 

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ControlTimeOut {

	
	public static <T> T call(Callable<T> callable) {
		ExecutorService executor = Executors.newCachedThreadPool();
		Future<T> future = executor.submit(callable);
		try {
			T t = future.get(3000, TimeUnit.MILLISECONDS);
			executor.shutdown();
			return t;
		} catch (InterruptedException e) {
			System.out.println("InterruptedException");
		} catch (ExecutionException e) {
			System.out.println("ExecutionException");
		} catch (TimeoutException e) {
			// TODO： coding here...
			System.out.println("TimeoutException");
		}
		return null;
	}
}
 

public class FutureTask implements Runnable {

	private String text;

	@Override
	public void run() {
		// TODO Auto-generated method stub
		String result = ControlTimeOut.call(new CallableImpl(text));
		System.out.println(text+"============="+Thread.currentThread().getName()+"================"+result);
	}

	public FutureTask(String text) {
		super();
		this.text = text;
	}

}
 

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import com.google.common.util.concurrent.ThreadFactoryBuilder;

public class FutureTest {

	public static void main(String[] args) throws InterruptedException {

		FutureTask task1 = new FutureTask("OK");
		FutureTask task2 = new FutureTask("not OK");
		FutureTask task3 = new FutureTask("not OK");
		FutureTask task4 = new FutureTask("not OK");
		FutureTask task5 = new FutureTask("not OK");
		FutureTask task6 = new FutureTask("not OK");
		FutureTask task7 = new FutureTask("not OK");
		FutureTask task8 = new FutureTask("not OK");
		FutureTask task9 = new FutureTask("OK");

		ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 50, 100, TimeUnit.MILLISECONDS,
				new ArrayBlockingQueue<Runnable>(100),
				new ThreadFactoryBuilder().setNameFormat("FutureTest-pool-%d").build());

		executor.submit(task1);
		executor.submit(task2);
		executor.submit(task3);
		executor.submit(task4);
		executor.submit(task5);
		executor.submit(task6);
		executor.submit(task7);
		executor.submit(task8);
		executor.submit(task9);
		while (executor.getActiveCount() > 0) {
			System.out.println("活躍執行緒為:" + executor.getActiveCount());
			Thread.sleep(3000);
		}
		System.out.println("活躍執行緒為:" + executor.getActiveCount());
		executor.shutdown();
	}

}

執行以後可以看出，超時的執行緒被終止了