设计一个线程超时终止的线程池

原贴地址：点击打开链接

起因是公司有一个定时任务，对于几千的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();
	}

}

在Main方法里面，创建多个FutureTask来模拟多个VPN联通任务，然后线程池来实现业务

运行以后可以看出，超时的线程被终止了