Java线程池深入理解

package com.coshaho.threadpool;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 线程池学习
 * @author coshaho
 */
public class MyThreadPool 
{
	/**
	 * 第一章  线程池初始化
	 */
	// 核心线程数量
	private int corePoolSize;
	// 最大线程数量
	private int maximumPoolSize;
	// 空闲线程存活时间
	private long keepAliveTime;
	// 空闲线程存活时间单位
	private TimeUnit unit;
	// 线程阻塞队列
	private BlockingQueue<Runnable> workQueue;
	/**
	 *  线程创建工厂，一般自定义，用于封装传入ThreadPool的Runnable任务
	 *  默认：Executors.defaultThreadFactory()
	 *  public interface ThreadFactory {  
	 *      Thread newThread(Runnable r); 
	 *  }
	 */
	private ThreadFactory threadFactory;
	// 线程拒绝机制
	private RejectedExecutionHandler handler;
	
	public void initThreadPoolExecutor()
	{
		ThreadPoolExecutor executor = new ThreadPoolExecutor(
				corePoolSize, 
				maximumPoolSize, 
				keepAliveTime, 
				unit,
				workQueue,
				threadFactory,
				handler);
		// 设置线程池核心线程数
		executor.setCorePoolSize(corePoolSize);
		// 设置线程池最大线程数
		executor.setMaximumPoolSize(maximumPoolSize);
		// 初始化一个核心线程
		executor.prestartCoreThread();
		// 初始化所有核心线程
		executor.prestartAllCoreThreads();
		// 不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
		executor.shutdown();
		// 立即终止线程池，尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务
		executor.shutdownNow();
	}

	/**
	 * 第二章  线程池任务处理机制
	 * 来了一个任务后的处理机制
	 * 1、 当线程池线程数量小于corePoolSize时，立即新建一个线程执行任务；
	 * 2、 当线程池线程数量等于corePoolSize，workQueue不满时，任务入workQueue队列，等待调度；
	 * 3、 当workQueue满，线程池线程数量小于maximumPoolSize时，新建线程执行任务；
	 * 4、 当线程池线程数量等于maximumPoolSize，workQueue满时，采用线程拒绝机制处理任务。
	 */
	
	/**
	 * 第三章  线程阻塞队列
     * workQueue的类型为BlockingQueue<Runnable>，通常可以取下面三种类型：
　　       * 1、ArrayBlockingQueue：基于数组的先进先出队列，此队列创建时必须指定大小；
　　       * 2、LinkedBlockingQueue：基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；
　　       * 3、synchronousQueue：这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。
	 */
	
	/**
	 * 第四章  线程拒绝机制
	 */
	public void rejectedExecutionHandlerLearn()
	{
		// 丢弃任务并抛出RejectedExecutionException异常
		handler = new ThreadPoolExecutor.AbortPolicy();
		// 也是丢弃任务，但是不抛出异常
		handler = new ThreadPoolExecutor.DiscardPolicy();
		// 丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
		handler = new ThreadPoolExecutor.DiscardOldestPolicy();
		// 由调用线程处理该任务 
		handler = new ThreadPoolExecutor.CallerRunsPolicy();
	}
	
	/**
	 * 第五章  JDK默认线程池
	 */
	
	public void jdkThreadPool()
	{
		//创建一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE
		Executors.newCachedThreadPool(); 
		//创建容量为1的缓冲池
		Executors.newSingleThreadExecutor();
		//创建固定容量大小的缓冲池  
		Executors.newFixedThreadPool(5);    
	}
	/**
	public static ExecutorService newFixedThreadPool(int nThreads) {
    	return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
	}
	public static ExecutorService newSingleThreadExecutor() {
    	return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
	}
	public static ExecutorService newCachedThreadPool() {
    	return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
	}
	*/
	
	/**
	 * 第六章  线程池大小设置
	 * 1、 如果是CPU密集型任务，就需要尽量压榨CPU，参考值可以设为 NCPU+1；
　　       * 2、 如果是IO密集型任务，参考值可以设置为2*NCPU。
	 */
	
	/**
	 * 第七章  JDK源码
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * @param handler the handler to use when execution is blocked
     *        because the thread bounds and queue capacities are reached
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue}
     *         or {@code threadFactory} or {@code handler} is null
     
     public ThreadPoolExecutor(int corePoolSize,
                               int maximumPoolSize,
                               long keepAliveTime,
                               TimeUnit unit,
                               BlockingQueue<Runnable> workQueue,
                               ThreadFactory threadFactory,
                               RejectedExecutionHandler handler)
     */
}