关于JAVA线程池

最近学习了JAVA线程池，应用最多的线程池一般有三种 newSingleThreadExecutor、newFixedThreadPool、newCachedThreadPool

 

newSingleThreadExecutor  创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

 

newFixedThreadPool  创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

 

newCachedThreadPool  创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

 

newSingleThreadExecutor  单线程池一般用于并发量不大的环境中

newCachedThreadPool   无边界线程池无疑要慎用，不然耗尽资源造成宕机后果无疑很严重

所以我推荐用newFixedThreadPool  有边界的线程池，实际大小可以根据生产环境加以调整，再加上一些拒绝任务的处理，在高并发的环境中无疑是非常好用的。

 

一下便是以newSingleThreadExecutor  做的例子

 

工作线程：

public class TestThread extends Thread {

	@Override
	public void run() {

		 TestThreadPool.testCount.addAndGet(1l);
//		System.out.println(i);

	}

}

 

 

线程池：

public class TestThreadPool {

	// public static int testCount = 0;
	public static AtomicLong testCount = new AtomicLong(0);
	public static AtomicLong rejectCount = new AtomicLong(0);

	private int corePoolSize = 30;
	private int maximumPoolSize = 60;
	private long keepAliveTime = 5l;
	private TimeUnit unit = TimeUnit.SECONDS;
	// private BlockingQueue<Runnable> workQueue = new
	// LinkedBlockingQueue<Runnable>(
	// 20);
	private BlockingQueue<Runnable> workQueue = new SynchronousQueue<Runnable>();

	// private ThreadPoolExecutor executor = new
	// ThreadPoolExecutor(corePoolSize,
	// maximumPoolSize, keepAliveTime, unit, workQueue);

	private ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize,
			maximumPoolSize, keepAliveTime, unit, workQueue,
			new ThreadRejectHandler());

	public static void main(String[] args) {
		int circle = 1000000;

		long start = Calendar.getInstance().getTimeInMillis();
		TestThreadPool test = new TestThreadPool();
		for (int i = 0; i < circle; i++) {
			try {
				test.executor.execute(new TestThread());
			} catch (Exception e) {
				e.printStackTrace();
			}

		}

		for (;;) {
			if ((testCount.get() + rejectCount.get()) == Long.valueOf(circle)) {
				System.out.println("testCount:" + testCount);
				break;
			}
		}
		long end = Calendar.getInstance().getTimeInMillis();
		System.out.println("耗时：[" + (end - start) + "] 毫秒");
		test.executor.shutdownNow();

	}
}

 

拒绝任务处理器：

public class ThreadRejectHandler implements RejectedExecutionHandler {

	@Override
	public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {

		System.out.println("任务被拒绝:"+TestThreadPool.rejectCount.addAndGet(1l));
		// 在这里做拒绝任务的处理
	}

}

 

 

启动类为《线程池类TestThreadPool 》，可以根据机器的配置调节circle参数的大小进行测试

 

我这里设置了circle为 1000000，  测试结果如下：

 

任务被拒绝:1

 

任务被拒绝:2

 

。。。。。。。。。。。。。此处略去N字

 

任务被拒绝:259

 

任务被拒绝:260

 

testCount:999740

 

耗时：[3266] 毫秒

 

 =======================================================================

 

使用线程池的优势：

因为通常情况下，创建线程是需要一定的耗时的，设这个时间为T1，而线程处理任务的时间为T2，而销毁线程的时间为T3，当T1>>T2时，同时T3时间也是一个需要考虑的参数，我们就应当考虑一种策略或者机制来控制，避免因为T1和T3这种无用的时间过多的占用资源。

所以线程池在高并发的环境中的优势是不言而喻的