线程池demo

ThreadPoolExecutor继承AbstractExecutorService；AbstractExecutorService实现ExecutorService；ExecutorService继承Executor类
ThreadPoolExecutor有4个构造函数

1. corePoolSize
   核心线程数，默认初始时为0，调用prestartAllCoreThreads()或prestartCoreThreads()预启动即没有任务时就创建corePoolSize线程
   int maximumPoolSize 最大线程数，线程池中最多能创建的线程数量

2. keepAliveTime 没有任务时最多保留多久时间终止

3. TimeUnit unit
   keepAliveTime的时间单位，keepAliveTime的时间单位，
   有7种TimeUnit.DAYS(天),
   TimeUnit.HOURS(时),
   TimeUnit.MINUTES(分),
   TimeUnit.SECONDS(秒),
   TimeUnit.MILLISECONDS(毫秒),
   TimeUnit.MICROSECONDS(微秒),
   TimeUnit.NANOSECONDS(纳秒)

4. BlockingQueue workQueue
   堵塞队列，用来执行等待任务
   有以下几种：arrayBlockingQueue 有界队列，初始化时需要指定队列大小(FIFO先进先出)
   linkedBlockingQueue 无界队列，队列大小与maximumPoolSize无关(FIFO先进先出)
   sysnchronousQueue 直接移交，不保存提交的任务，而是将直接新建一个线程来执行新来的任务

5. threadFactory
   创建线程的工厂 默认Executors.defaultThreadFactory()

6. Handler
   拒绝处理任务时的策略 默认defaultHandler=new AbortPolicy()
   有4种拒绝策略：
   ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
   ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
   ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
   ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

7. 提交任务
   execute() 参数为Runnable,没有返回值，用来执行传入的任务
   submit()在AbstractExecutorService中有具体实现，没在ThreadPoolExecutor进行重新，返回Future<?>，底层实际上也调用execute()

8. 关闭线程
   当创建线程池后，初始时，线程池处于RUNNING状态；
   private static final int RUNNING = -1 << COUNT_BITS;
   private static final int SHUTDOWN = 0 << COUNT_BITS;
   private static final int STOP = 1 << COUNT_BITS;
   private static final int TIDYING = 2 << COUNT_BITS;
   private static final int TERMINATED = 3 << COUNT_BITS;
   pool.shutdown():调用shutdown()后，线程状态处于SHUTDOWN状态，线程池不接受新的任务，等待所有任务执行完毕
   pool.shutdownNow()：调用shutdownNow()后，线程处于STOP状态，线程不接受新的任务，尝试终止正在执行的任务，并且返回等待任务列表
   当等待队列和线程池为空时为TIDYING状态/线程池为空时为TIDYING状态（STOP -> TIDYING、SHUTDOWN -> TIDYING）
   当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态

package thread;

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

public class ThreadPoolExcutorDemo {
	public static void main(String[] args) {
		//等待线程队列
		ArrayBlockingQueue<Runnable> workQueue=new ArrayBlockingQueue<Runnable>(5);
		ThreadPoolExecutor pool=new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS, workQueue);
		for (int i = 0; i < 15; i++) {
			MyTask myTask=new MyTask(i);
		   pool.execute(myTask);
			System.out.println("线程池线程数量："+pool.getPoolSize()+",队列中等待线程数："+pool.getQueue().size()+",已执行完线程数量："+pool.getCompletedTaskCount());
		}
		System.out.println(pool.isShutdown());
		pool.shutdown();
		System.out.println(pool.isShutdown());
		System.out.println(pool.isTerminated());
	}

}

class MyTask implements Runnable{

	public int taskNum;
	
	public MyTask(int num){
		this.taskNum=num;
	}
	@Override
	public void run() {
		System.out.println("正在执行task"+taskNum);
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("任务task"+taskNum+"执行完毕");
	}
	
}