java多线程系列16 线程池

当系统系统规模较小，我们可以不使用线程池。但是当系统到达一定规模，频繁的创建和销毁线程池会消耗很多资源。

合理利用线程池能够带来三个好处。

1降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

2提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

3提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

下面演示下线程池的基本的使用

public class ThreadPoolExecutorTest {
	public static void main(String[] args) {
		ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
				new LinkedBlockingQueue<Runnable>());

		Runnable runnable = null;
		for (int i = 0; i < 20; i++) {
			runnable = new Runnable() {
				@Override
				public void run() {
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + " run");
				}
			};
			executor.execute(runnable);
		}
		executor.shutdown();
	}
}

　　

Jdk默认了实现了4种线程池。
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，默认是60秒，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

查看源码 ，都是调用

其本质是通过不同的参数初始化一个ThreadPoolExecutor对象，只是传递的参数不同罢了

具体参数解释如下：

corePoolSize 线程池中的核心线程数，

maximumPoolSize 线程池中允许的最大线程数

keepAliveTime 线程空闲时的存活时间，即当线程没有任务执行时，继续存活的时间

keepAliveTime的 单位 unit

workQueue

用来保存等待被执行的任务的阻塞队列，且任务必须实现Runable接口，在JDK中提供了如下阻塞队列：
ArrayBlockingQueue：基于数组的有界阻塞队列，按FIFO排序任务；
LinkedBlockingQuene：基于链表的无界阻塞队列，按FIFO排序任务，吞吐量通常要高于ArrayBlockingQuene；
SynchronousQuene：一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQuene；
priorityBlockingQuene：具有优先级的无界阻塞队列；

handler

线程池的拒绝策略，当阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，必须采取一种策略处理该任务，线程池内置了4种策略：
1、AbortPolicy：直接抛出异常，默认策略；
2、CallerRunsPolicy：用调用者所在的线程来执行任务；
3、DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
4、DiscardPolicy：直接丢弃任务；
当然我们也可以根据应用场景实现RejectedExecutionHandler接口，自定义拒绝策略，

实际开发中，一般先记录日志 再开一个定时去处理

执行流程图如下

 

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

原理解析 

 

找到线程池核心的execute()方法 源代码如下 

 

 if (command == null)
            throw new NullPointerException();
//ctl是一个包装变量 包含了线程池的状态以及线程池中线程数
        int c = ctl.get();
        //workerCountOf 获取线程池的当前线程数
     if (workerCountOf(c) < corePoolSize) { // 【步骤1】
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
    if (isRunning(c) && workQueue.offer(command)) { // 【步骤2】
            int recheck = ctl.get();
          if (! isRunning(recheck) && remove(command))   //【步骤4】
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
     else if (!addWorker(command, false)) // 【步骤3】
            reject(command);
    }

 

　　

具体的执行流程如下：
--> 如果线程数小于corePoolSize，则执行addWorker方法创建新的线程执行任务 并返回 ；否则执行步骤2；
--> 如果线程池处于RUNNING状态，并且任务成功放入阻塞队列中，则执行步骤4，否则执行 步骤3
--> 再次检查线程池的状态，如果线程池没有RUNNING，并且从阻塞队列中删除任务，则执行reject方法处理任务；
--> 执行addWorker方法创建新的线程执行任务，如果addWoker执行失败，则执行reject方法处理任务；

接下来我们看看addWorker方法

addWorker分为2部分

retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
//通过自旋的方式，判断要添加的Worker是否是true，如果是的话，那么
//则判断当前的workerCount是否大于corePoolsize，否则则判断是否大于//maximumPoolSize，如果满足的话，说明workerCount超出了线程池大小，直//接返回false 如果没有超出就cas让workerCount+1 如果成功就跳出循环 失//败就继续进行状态的判断
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }
--------第一部分完 
/*如果满足了的话，那么则创建一个新的Worker对象 满足状态就添加到works中 然后启动Worker中的线程开始执行任务*/
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    int rs = runStateOf(ctl.get());
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }