Java线程池的测试和分析

 

package cn.smallbug.jdk.concurrent.exe;

import java.io.Serializable;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.DiscardPolicy;
import java.util.concurrent.TimeUnit;

import org.junit.Before;
import org.junit.Test;

public class TestThreadPoolExecutor {

	private ThreadPoolExecutor pool = null;

	@Before
	public void before() {
		this.pool = new ThreadPoolExecutor(//
				/**
				 * corePoolSize（线程池的基本大小）：<br />
				 * 当提交一个任务到线程池时，线程池会创建一个线程来执行任务，
				 * 即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。
				 * 如果调用了线程池的prestartAllCoreThreads方法，线程池会提前创建并启动所有基本线程。
				 */
				10,
				/**
				 * maximumPoolSize（线程池最大大小）：<br />
				 * 线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。
				 * 值得注意的是如果使用了无界的任务队列这个参数就没什么效果。
				 */
				20,
				/**
				 * keepAliveTime（线程活动保持时间）：<br />
				 * 线程池的工作线程空闲后，保持存活的时间。
				 */
				1000,
				/**
				 * TimeUnit（线程活动保持时间的单位）:<br />
				 * 可选：<br />
				 * <ul>
				 * <li>单位有天（DAYS）</li>
				 * <li>小时（HOURS）</li>
				 * <li>分钟（MINUTES）</li>
				 * <li>毫秒(MILLISECONDS)</li>
				 * <li>微秒(MICROSECONDS, 千分之一毫秒)</li>
				 * <li>毫微秒(NANOSECONDS, 千分之一微秒)</li>
				 * </ul>
				 */
				TimeUnit.MILLISECONDS, // 表示线程活动保持时间为1000ms，
				/**
				 * runnableTaskQueue（任务队列）：<br />
				 * 用于保存等待执行的任务的阻塞队列。可以选择以下几个阻塞队列:
				 * <ul>
				 * <li><b>ArrayBlockingQueue：</b>是一个基于数组结构的有界阻塞队列，此队列按
				 * FIFO（先进先出）原则对元素进行排序。</li>
				 * <li><b>LinkedBlockingQueue：</b>一个基于链表结构的阻塞队列，此队列按FIFO （先进先出）
				 * 排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.
				 * newFixedThreadPool()使用了这个队列。</li>
				 * <li><b>SynchronousQueue：</b>
				 * 一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，
				 * 否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.
				 * newCachedThreadPool使用了这个队列。</li>
				 * <li><b>PriorityBlockingQueue：</b>一个具有优先级的无限阻塞队列。</li>
				 * </ul>
				 */
				new ArrayBlockingQueue<Runnable>(100),
				/**
				 * ThreadFactory：<br />
				 * 用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字，Debug和定位问题时非常又帮助。
				 */
				// new CreateThread(),
				/**
				 * RejectedExecutionHandler（饱和策略）：<br />
				 * 当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。
				 * 这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。以下是JDK1.5提供的四种策略
				 * <ul>
				 * <li>CallerRunsPolicy：只用调用者所在线程来运行任务。</li>
				 * <li>DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。</li>
				 * <li>DiscardPolicy：不处理，丢弃掉。</li>
				 * <li>当然也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。
				 * 如记录日志或持久化不能处理的任务。</li>
				 * </ul>
				 */
				new DiscardPolicy()//
		);
	}

	/**
	 * 线程池在创建时如果指定任务工厂execute的任务将无效
	 * 
	 * @timestamp Mar 19, 2016 3:08:56 PM
	 */
	@Test
	public void testExecute() {
		pool.execute(new Runnable() {

			@Override
			public void run() {
				System.out.println(2 + 2);
			}

		});
	}

	/**
	 * 线程池在创建时如果指定任务工厂execute的任务将无效
	 * 
	 * @timestamp Mar 19, 2016 3:11:21 PM
	 */
	@Test
	public void testSubmit() {
		int i = 100;
		while (i-- > 0) {
			pool.submit(//
					new Callable<Serializable>() {

						@Override
						public Serializable call() throws Exception {
							return 2 + 2;
						}
					}//
			);
		}
		Future<Serializable> result = pool.submit(//
				new Callable<Serializable>() {

					@Override
					public Serializable call() throws Exception {
						return 2 + 2;
					}
				}//
		);
		Serializable s = null;
		try {
			s = (int) result.get();
		} catch (InterruptedException e) {
			// 处理中断异常
			e.printStackTrace();
		} catch (ExecutionException e) {
			// 处理无法执行任务异常
			e.printStackTrace();
		} finally {
			stastic(pool);
			/**
			 * 1、将线程池的状态设置成SHUTDOWN状态<br />
			 * 2、然后中断所有没有正在执行任务的线程
			 */
			pool.shutdown();
			/**
			 * 1、将线程池的状态设置成STOP<br />
			 * 2、遍历线程池中的工作线程<br />
			 * 3、逐个调用线程的interrupt方法来中断线程（无法响应中断的任务可能永远无法终止）<br />
			 * 4、返回等待执行任务的列表
			 */
			// pool.shutdownNow();
			/**
			 * 只要调用了这两个关闭方法的其中一个，isShutdown方法就会返回true<br />
			 * 当所有的任务都已关闭后,才表示线程池关闭成功，这时调用isTerminaed方法会返回true<br />
			 * 通常调用shutdown来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow
			 */
		}
		System.out.println(s);

	}

	/**
	 * 通过继承线程池并重写线程池的 <br />
	 * beforeExecute <br />
	 * afterExecute <br />
	 * terminated <br />
	 * 方法，可以在任务执行前， 执行后和线程池关闭前干一些事情。如监控任务的平均执行时间，最大执行时间和最小执行时间等。
	 * 
	 * @timestamp Mar 19, 2016 3:37:29 PM
	 * @param pool2
	 */
	private void stastic(ThreadPoolExecutor pool) {
		System.out.println("current cpu num -> " + Runtime.getRuntime().availableProcessors());
		System.out.println("线程池需要执行的任务数量 -> " + pool.getTaskCount());
		System.out.println("线程池在运行过程中已完成的任务数量。小于或等于taskCount -> " + pool.getCompletedTaskCount());
		System.out.println("线程池曾经创建过的最大线程数量 -> " + pool.getLargestPoolSize());
		System.out.println("线程池的线程数量。如果线程池不销毁的话，池里的线程不会自动销毁，所以这个大小只增不减 -> " + pool.getPoolSize());
		System.out.println("获取活动的线程数 -> " + pool.getActiveCount());
	}

	/**
	 * 工作任务创建工厂
	 * 
	 * @timestamp Mar 19, 2016 3:01:24 PM
	 * @author smallbug
	 */
	class CreateThread implements ThreadFactory {
		@Override
		public Thread newThread(Runnable r) {
			return new Thread() {
				@Override
				public void run() {
					System.out.println(1 + 1);
				}
			};
		}

	}
}

 
          

 

 

1. 首先线程池判断基本线程池是否已满？没满，创建一个工作线程来执行任务。满了，则进入下个流程。
2. 其次线程池判断工作队列是否已满？没满，则将新提交的任务存储在工作队列里。满了，则进入下个流程。
3. 最后线程池判断整个线程池是否已满？没满，则创建一个新的工作线程来执行任务，满了，则交给饱和策略来处理这个任务。

参考博客：聊聊并发（三）Java线程池的分析和使用