Java线程池
什么是线程池?
线程池：从它名字上来看，就是把一堆线程放进一个池子里面，来任务后取出池子里面的线程，工作完后放回池子。
为什么要使用这个？
首先要明白线程分为用户级线程和内核级别线程。我们使用new Thread()创建的线程其实底层是通过系统调用创建的内核级别线程。既然是内核级别线程，那么必然会创建一个TCB，TCB是消耗内存的。
所以
好处1：能够避免频繁的系统调用。系统调用对于任何一个操作系统开销都是很大的。
好处2：消耗内存，熟悉JVM的都知道，虚拟机栈、程序计算器是随着线程的生命周期的，自然而然，当并发量高的时候，这些东西也会创建很多，栈默认是1m,可以通过-xss参数来改变大小。
用法：
自定义线程池构造方法
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory， RejectedExecutionHandler handle) {};
一共有7个参数：
corePoolSize：核心线程数，这些线程是一直存在线程池中的
maximumPoolSize：最大线程数
keepAliveTime：存活时间，当超过核心线程线程后，但是小于最大线程数，这些线程如果没有任务，会在keepAliveTime时间后消亡。
unit：单位，keepAliveTime的单位。
workQueue：阻塞队列，这里规定了阻塞队列里面放的元素必须是Runnable，当核心线程都在工作时，这时候新来的任务就会被放进阻塞队列。
threadFactory：线程工厂。
我们看看threadFactory是啥，其实里面很简单，就是接口，里面有个方法来返回创建的后的线程，简单点说：线程池里面的线程都是通过下面的方法newThread()来创建的
public interface ThreadFactory {
/**
* Constructs a new {@code Thread}. Implementations may also initialize
* priority, name, daemon status, {@code ThreadGroup}, etc.
*
* @param r a runnable to be executed by new thread instance
* @return constructed thread, or {@code null} if the request to
* create a thread is rejected
*/
Thread newThread(Runnable r);
}
handler：拒绝策略。简单点说就是当你最大线程数的线程都在工作时，并且阻塞队列也满了，这个时候你怎么去处理新的任务。jdk提供了四种拒绝策略：
ThreadPoolExecutor.CallerRunsPolicy(): 抛弃旧的任务
ThreadPoolExecutor.DiscardPolicy() :抛弃当前的任务
ThreadPoolExecutor.AbortPolicy() :抛出java.util.concurrent.RejectedExecutionException异常, Default异常
ThreadPoolExecutor.CallerRunsPolicy() :由创建了线程池的线程来执行被拒绝的任务
也可以自定义自己的拒绝策略，实现下面的接口就行
public interface RejectedExecutionHandler {
/**
* Method that may be invoked by a {@link ThreadPoolExecutor} when
* {@link ThreadPoolExecutor#execute execute} cannot accept a
* task. This may occur when no more threads or queue slots are
* available because their bounds would be exceeded, or upon
* shutdown of the Executor.
*
* <p>In the absence of other alternatives, the method may throw
* an unchecked {@link RejectedExecutionException}, which will be
* propagated to the caller of {@code execute}.
*
* @param r the runnable task requested to be executed
* @param executor the executor attempting to execute this task
* @throws RejectedExecutionException if there is no remedy
*/
void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}
原理:
构造方法很简单，就不具体展开了
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) { //参数校验 if (corePoolSize < 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize || keepAliveTime < 0) throw new IllegalArgumentException(); if (workQueue == null || threadFactory == null || handler == null) throw new NullPointerException(); //暂时不知道是啥，不影响整体流程 this.acc = System.getSecurityManager() == null ? null : AccessController.getContext(); //赋值 this.corePoolSize = corePoolSize; this.maximumPoolSize = maximumPoolSize; this.workQueue = workQueue; this.keepAliveTime = unit.toNanos(keepAliveTime); this.threadFactory = threadFactory; this.handler = handler; }
关键方法：
注意：ctl 可以理解是两个字段的打包，一个是线程池的状态，后面一个是workerCount，可以看到初始化时，是RUNNING和0；
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); public void execute(Runnable command) { //1.参数校验 if (command == null) throw new NullPointerException(); //获取ctl的值 int c = ctl.get(); //通过workerCountOf(c)反过来获取workerCount，如果小于核心线程数 if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; c = ctl.get(); } //如果大于核心线程数，并且能够正常加入阻塞队列，注意这里用的是offer，不是add if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get(); //线程池关闭了 if (! isRunning(recheck) && remove(command)) reject(command); //wc == 0,不知道这种是什么情况，暂时不用管 else if (workerCountOf(recheck) == 0) addWorker(null, false); } //如果满了，尝试加入最大线程，可以看到后面参数为false,这里就表示为最大线程 else if (!addWorker(command, false)) //加入失败，执行拒绝策略。里面代码很简单 reject(command); }
//这里core表示新加的线程是否是核心线程 private boolean addWorker(Runnable firstTask, boolean core) { retry: for (;;) { int c = ctl.get(); //通过runStateOf函数返过来获取线程池状态 int rs = runStateOf(c); // 校验 if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) return false; for (;;) { int wc = workerCountOf(c); //校验当前workerCount if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)) return false; //通过CAS则增加ctl的值，增加失败，就重试，这里解决多线程下并发增加ctl问题 if (compareAndIncrementWorkerCount(c)) break retry; //增加失败重新获取ctl值 c = ctl.get(); // Re-read ctl //如果线程池状态发生改变 if (runStateOf(c) != rs) continue retry; // else CAS failed due to workerCount change; retry inner loop } } boolean workerStarted = false; boolean workerAdded = false; Worker w = null; try { //创建Worker w = new Worker(firstTask); final Thread t = w.thread; if (t != null) { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { // Recheck while holding lock. // Back out on ThreadFactory failure or if // shut down before lock acquired. int rs = runStateOf(ctl.get()); //又是线程池状态校验 if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { if (t.isAlive()) // precheck that t is startable throw new IllegalThreadStateException(); //增加这个worker 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; }
看看new Worker(),可以就看到创建了一个worker，一个worker里面有一个线程，这个线程就是我们的线程池构造方法里面的线程工厂创建的，但是的Runnable是这个Worker
因为Worker类是实现了了Runnable的，这里有点绕
private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
}
当线程调用start方法后，cpu会自动调用run()方法。也就是worker里面的run方法
public void run() { runWorker(this); } final void runWorker(Worker w) { //获取当前线程 Thread wt = Thread.currentThread(); //获取任务 Runnable task = w.firstTask; //将这个worker里面任务置为空， w.firstTask = null; w.unlock(); // allow interrupts boolean completedAbruptly = true; try { //当task不为空 while (task != null || (task = getTask()) != null) { w.lock(); // If pool is stopping, ensure thread is interrupted; // if not, ensure thread is not interrupted. This // requires a recheck in second case to deal with // shutdownNow race while clearing interrupt if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted()) wt.interrupt(); try { //执行任务前要执行的方法，可以扩展，默认为空方法 beforeExecute(wt, task); Throwable thrown = null; try { //直接调用run方法 task.run(); } catch (RuntimeException x) { thrown = x; throw x; } catch (Error x) { thrown = x; throw x; } catch (Throwable x) { thrown = x; throw new Error(x); } finally { //执行完后需要调用的方法，可以扩展，默认为空方法 afterExecute(task, thrown); } } finally { task = null; w.completedTasks++; w.unlock(); } } completedAbruptly = false; } finally { //执行完了，移除worker，其实这里正常情况下只会移除非核心线程 processWorkerExit(w, completedAbruptly); } }
从阻塞队列里面获取任务
private Runnable getTask() { boolean timedOut = false; // Did the last poll() time out? //死循环 for (;;) { int c = ctl.get(); int rs = runStateOf(c); // Check if queue empty only if necessary. if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) { decrementWorkerCount(); return null; } int wc = workerCountOf(c); // Are workers subject to culling? //可以看到后面wc>corePoolSize，就是大于核心线程数 boolean timed = allowCoreThreadTimeOut || wc > corePoolSize; //这里回收worker， if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) { //CAS减少workerCount数量 if (compareAndDecrementWorkerCount(c)) return null; continue; } try { Runnable r = timed ? //多少时候就不等了，这里keepAliveTime其实就是我们传进来的参数，相当于如果大于核心线程数，如果keepAliveTime时候后，仍然取不到，会减少workerCount的数量 workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : //阻塞，等待队列里面有任务，核心线程就是，所以核心线程不会退出 workQueue.take(); if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { timedOut = false; } } }
总结与思考：
到这里也就大致明白了几个点：
第一：核心线程为什么不会消亡？
因为核心线程从阻塞队列里面取任务时，采用的take()，它是阻塞的。
第二：非核心线程为什么会消亡？
其实核心线程和非核心线程是一样的，只是在获取任务时，会判断当前wc(workerCount)数量，如果大于核心线程，就会执行CAS减少worker数量，通过CAS来确保多线程下workerCount数量的正确性，然后移除这个worker。
第三：一个线程为什么能够执行多个任务？
其实线程还是只能执行一个任务，只不过这个任务是不断的从阻塞队列里面取出任务，调用它们的run()方法进行执行。
第四：如果线程次第一个线程执行完了，summit第二个任务时，会新开启一个线程吗？
会，从源码角度上看，只要线程池数量小于核心线程数，都是先加入线程，当大于核心线程数后，才会进入阻塞队列，从阻塞队列里面取。
