线程池原理

避免每次新起线程对内存的消耗，降低资源消耗，提高内存利用率，使用线程池将线程管理起来。

线程池 Executor

// 基础用法public class ExecutorTest {    public static void main(String[] args) {        // 可伸缩的线程池 大小为10        Executor executor = Executors.newFixedThreadPool(10);        // 提交20个线程        for (int i = 0; i < 20; i++) {            executor.execute(new RunnableCase());        }    }}class RunnableCase implements Runnable{    @Override    public void run() {        System.out.println("Hello" + Thread.currentThread().getName());    }}

Executor 框架管理了所有线程的生命周期

Executors

Executors是一个工厂类，可以生成多种线程池。就newFixedThreadPool来看

public static ExecutorService newFixedThreadPool(int nThreads) {        return new ThreadPoolExecutor(nThreads, nThreads,                                      0L, TimeUnit.MILLISECONDS,                                      new LinkedBlockingQueue<Runnable>());}public ThreadPoolExecutor(int corePoolSize,                              int maximumPoolSize,                              long keepAliveTime,                              TimeUnit unit,                              BlockingQueue<Runnable> workQueue) {        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,             Executors.defaultThreadFactory(), defaultHandler);    }

• corePoolSize：线程池中的核心线程数，如果线程池中执行的线程数等于corePoolSize的时候，如果有新任务，则会放到阻塞队列里。线程池的prestartAllCoreThreads()方法可以提前创建并启动所有核心线程。
• maxmiumPoolSize：线程池中允许最大的线程数，当阻塞队列满的时候，如果线程池中的线程数目小雨maxmiumPooSize，则会创建新的线程执行。
• keepAliveTime：线程空闲时的存活时间，即当线程没有任务执行时，继续存活的时间；默认情况下，该参数只在线程数大于corePoolSize时才有用
• unit：表示的时间单位。

• workQueue：用于保存超出corePoolSize的线程，具有如下特性：
  1、ArrayBlockingQueue：基于数组结构的有界阻塞队列，按FIFO排序任务；
  2、LinkedBlockingQuene：基于链表结构的阻塞队列，按FIFO排序任务，吞吐量通常要高于ArrayBlockingQuene；
  3、SynchronousQuene：一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQuene；
  4、priorityBlockingQuene：具有优先级的无界阻塞队列；

  threadFactory

  DefaultThreadFactory() {        SecurityManager s = System.getSecurityManager();        group = (s != null) ? s.getThreadGroup() :                              Thread.currentThread().getThreadGroup();        namePrefix = "pool-" +                      poolNumber.getAndIncrement() +                     "-thread-";    }

  线程创建工厂，给线程定义线程名。

  handler

  线程池以及队列满了以后的如果有任务提交的处理策略。
  “`
  // 默认的是AbortPolicy
  private static final RejectedExecutionHandler defaultHandler =new AbortPolicy();

// AbortPolicy 拒绝策略
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException(“Task ” + r.toString()
+ ” rejected from ” + e.toString());
}
}
“`

1. AbortPolicy：默认策略、直接抛出异常。
2. CallerRunsPolicy：用调用者所在的线程来执行任务；
3. DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
4. DiscardPolicy：直接丢弃任务；
   注意：如果以上策略都不满足的话，可实现RejectedExecutionHandler接口，自定义处理策略。

各种线程池说明

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {        return new ThreadPoolExecutor(nThreads, nThreads,                                      0L, TimeUnit.MILLISECONDS,                                      new LinkedBlockingQueue<Runnable>());}

corePoolSize == maximumPoolSize，Queue为LinkingBlockingQueue，当线程池没有可执行任务时，也不会释放线程。

---

newCachedThreadPool

public static ExecutorService newCachedThreadPool() {        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,                                      60L, TimeUnit.SECONDS,                                      new SynchronousQueue<Runnable>());}

可缓存的线程池，默认缓存60s，线程池的线程数可达到Integer.MAX_VALUE，使用SynchronousQueue作为阻塞队列；
newCachedThreadPool在没有任务执行时，当线程的空闲时间超过keepAliveTime，会自动释放线程资源，当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销；

---

ScheduledThreadPoolExecutor

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {    return new ScheduledThreadPoolExecutor(corePoolSize);}public ScheduledThreadPoolExecutor(int corePoolSize) {    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,    new DelayedWorkQueue());}

周期性提交任务。

---

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {    return new FinalizableDelegatedExecutorService        (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,            new LinkedBlockingQueue<Runnable>()));}

线程池中只有一个线程，如果线程异常结束，则会创建一个新的线程继续执行任务。

---

实现原理

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));    // 29    private static final int COUNT_BITS = Integer.SIZE - 3;    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;    // runState is stored in the high-order bits    // 11100000000000000000000000000000    private static final int RUNNING    = -1 << COUNT_BITS;    // 0    private static final int SHUTDOWN   =  0 << COUNT_BITS;    // 100000000000000000000000000000    private static final int STOP       =  1 << COUNT_BITS;    // 1000000000000000000000000000000    private static final int TIDYING    =  2 << COUNT_BITS;    private static final int TERMINATED =  3 << COUNT_BITS;    // Packing and unpacking ctl    private static int runStateOf(int c)     { return c & ~CAPACITY; }    private static int workerCountOf(int c)  { return c & CAPACITY; }    private static int ctlOf(int rs, int wc) { return rs | wc; }

利用高3位表示线程状态。
1、RUNNING：111，正常状态，接受新的任务，并处理任务队列中的任务；
2、SHUTDOWN：000，不接受新的任务，但是处理已经在任务队列中的任务；
3、STOP ： 001，不接受新的任务，也不处理已经在任务队列中的任务，同时会尝试停止正在执行任务的线程；
4、TIDYING ： 010，线程池和任务队列都为空，该状态下线程会执行 terminated() 方法；
5、TERMINATED：011，terminated() 方法执行完毕；

提交任务方式

两种提交方式Executor.execute() 和ExecutorService.submit()

Executor.execute()

void execute(Runnable command);

只接受实现了Runnable接口的对象，无返回值，无法获取线程结果。

---

ExecutorService.submit()

<T> Future<T> submit(Callable<T> task);

可以通过Future获取返回值。

---

任务执行

Executor.execute()

public void execute(Runnable command) {    if (command == null)        throw new NullPointerException();    int c = ctl.get();    if (workerCountOf(c) < corePoolSize) {        if (addWorker(command, true))            return;        c = ctl.get();    }    if (isRunning(c) && workQueue.offer(command)) {        int recheck = ctl.get();        if (! isRunning(recheck) && remove(command))            reject(command);        else if (workerCountOf(recheck) == 0)            addWorker(null, false);    }    else if (!addWorker(command, false))        reject(command);}

流程说明
1. 判定线程池任务是否小于核心线程数，如果小于则执行addWorker方法创建新的线程执行任务，如果大于执行步骤2
2. 如果线程池是running状态，则把任务放进阻塞队列，然后执行步骤3，如果放入失败则执行步骤4。
3. 再次判断线程池状态是否为running，如果不是，则从队列里删除该命令，执行reject方法来处理。如果线程池中的任务为0，则addWorker添加空任务。
4. 执行addWorker方法创建新的线程执行任务，如果失败，则执行reject方法。

addWorker实现

addWorker在线程池中主要负责创建线程执行任务

private boolean addWorker(Runnable firstTask, boolean core) {/*--------------------------------第1段----------------------*/    retry:    for (;;) {        int c = ctl.get();        int rs = runStateOf(c);        // Check if queue empty only if necessary.        if (rs >= SHUTDOWN &&            ! (rs == SHUTDOWN &&               firstTask == null &&               ! workQueue.isEmpty()))            return false;        for (;;) {            int wc = workerCountOf(c);            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        }    }/*--------------------------------第2段----------------------*/    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 {                // 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();                    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;}

第1段
1. 如果线程池状态大于等于SHUTDOWN，则返回，除非状态为SHUTDOWN&&提交的任务为空&&队列为空。
2. 判断是否为核心线程，如果是，则大于coreSize就返回false，如果不是，则大于maxmumPoolSize就返回。
3. 跳出循环开始第2段，创建线程

第2段
加锁的情况下，新建Worker类，将worker插入到workers里，并启动worker中的线程。
Worker代码

 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);}/** Delegates main run loop to outer runWorker  */public void run() {    runWorker(this);}

1. 继承了AbstractQueuedSynchronizer类，可控制线程的中止；
2. 实现了Runnable接口，自身就是一个任务；
3. 传入Runnable参数；
4. 创建了线程的同时传入了自身，线程执行方法调用的是runWorker方法。

runWorker方法

final void runWorker(Worker w) {        Thread wt = Thread.currentThread();        Runnable task = w.firstTask;        w.firstTask = null;        w.unlock(); // allow interrupts        boolean completedAbruptly = true;        try {            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 {                        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 {            processWorkerExit(w, completedAbruptly);        }    }

1. 先通过unlock方法释放锁，completedAbruptly设为true。
2. 上锁，执行beforeExecute方法；然后执行run方法，最后执行afterExecute方法
3. 执行完以后，会调用getTask来从阻塞队列获取等待任务，如果没有，则挂起

getTask

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?        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;        if ((wc > maximumPoolSize || (timed && timedOut))            && (wc > 1 || workQueue.isEmpty())) {            if (compareAndDecrementWorkerCount(c))                return null;            continue;        }        try {            Runnable r = timed ?                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :                workQueue.take();            if (r != null)                return r;            timedOut = true;        } catch (InterruptedException retry) {            timedOut = false;        }    }}

for循环的情况下
1.workQueue.take，从阻塞线程中获取线程，如队列无线程则阻塞，如有线程，则获取并返回。
2.workQueue.poll，在keepAlive时间内还未返回，则返回null
注意：从以上程序可以看出，执行完线程之后，会尝试从队列获取线程，保证了队列中的线程可以被执行。

Future和Callable

如果需要线程返回结果，则需要用到Future和Callable，还需要使用ExecutorService.submit()方法提交。

public class ExecutorTest {    public static void main(String[] args) {        // 可伸缩的线程池        ExecutorService service = Executors.newFixedThreadPool(10);        Future<String> future = service.submit(new CallableCase());        String result = null;        try {            result = future.get();        } catch (InterruptedException e) {            e.printStackTrace();        } catch (ExecutionException e) {            e.printStackTrace();        }        System.out.println(result);    }}class CallableCase implements Callable<String> {    @Override    public String call() throws Exception {        Thread.sleep(20000);        return "sleep thread";    }}

Callable负责返回值，Future可获取Callable返回的结果。
1. Future可以获取返回值以及异常值
2. Future.get方法会一直阻塞到Callable有返回值。

ExecutorService.submit方法

public <T> Future<T> submit(Callable<T> task) {    if (task == null) throw new NullPointerException();       RunnableFuture<T> ftask = newTaskFor(task);       execute(ftask);       return ftask;}protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {    return new FutureTask<T>(callable);}

Callable任务会被封装成FutureTask对象。

private volatile int state;private static final int NEW          = 0;private static final int COMPLETING   = 1;private static final int NORMAL       = 2;private static final int EXCEPTIONAL  = 3;private static final int CANCELLED    = 4;private static final int INTERRUPTING = 5;private static final int INTERRUPTED  = 6;

有多种状态

public class FutureTask<V> implements RunnableFuture<V>public interface RunnableFuture<V> extends Runnable, Future<V>

可以看出来FutureTask实现了Runnable状态，所以可以使用ExecutorService来提交。最终执行的是FutureTask.run方法

FutureTask.get

public V get() throws InterruptedException, ExecutionException {    int s = state;    if (s <= COMPLETING)        s = awaitDone(false, 0L);    return report(s);}

通过awaitDone来等待结果返回

awaitDone

private int awaitDone(boolean timed, long nanos)    throws InterruptedException {    final long deadline = timed ? System.nanoTime() + nanos : 0L;    WaitNode q = null;    boolean queued = false;    for (;;) {        if (Thread.interrupted()) {            removeWaiter(q);            throw new InterruptedException();        }        int s = state;        if (s > COMPLETING) {            if (q != null)                q.thread = null;            return s;        }        else if (s == COMPLETING) // cannot time out yet            Thread.yield();        else if (q == null)            q = new WaitNode();        else if (!queued)            queued = UNSAFE.compareAndSwapObject(this, waitersOffset,                                                 q.next = waiters, q);        else if (timed) {            nanos = deadline - System.nanoTime();            if (nanos <= 0L) {                removeWaiter(q);                return state;            }            LockSupport.parkNanos(this, nanos);        }        else            LockSupport.park(this);    }}

1. 如果主线程被中断，则抛出中断异常；
2. 判断FutureTask当前的state，如果大于COMPLETING，说明任务已经执行完成，则直接返回；
3. 如果当前state等于COMPLETING，说明任务已经执行完，这时主线程只需通过yield方法让出cpu资源，等待state变成NORMAL；
4. 通过WaitNode类封装当前线程，并通过UNSAFE添加到waiters链表；
5. 最终通过LockSupport的park或parkNanos挂起线程；

FutureTask.run

public void run() {    if (state != NEW ||        !UNSAFE.compareAndSwapObject(this, runnerOffset,                                     null, Thread.currentThread()))        return;    try {        Callable<V> c = callable;        if (c != null && state == NEW) {            V result;            boolean ran;            try {                result = c.call();                ran = true;            } catch (Throwable ex) {                result = null;                ran = false;                setException(ex);            }            if (ran)                set(result);        }    } finally {        // runner must be non-null until state is settled to        // prevent concurrent calls to run()        runner = null;        // state must be re-read after nulling runner to prevent        // leaked interrupts        int s = state;        if (s >= INTERRUPTING)            handlePossibleCancellationInterrupt(s);    }}

1. 执行Callable.call方法。
2. 如果执行成功有结果，通过set保存对象。
3. 如果有异常，则保存异常。

set方法

protected void set(V v) {    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {        outcome = v;        UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state        finishCompletion();    }}

setException方法

protected void setException(Throwable t) {  if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {        outcome = t;        UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state        finishCompletion();    }}

set和setException方法中，都会通过UnSAFE修改FutureTask的状态，并执行finishCompletion方法通知主线程任务已经执行完成；

finishCompletion

private void finishCompletion() {    // assert state > COMPLETING;    for (WaitNode q; (q = waiters) != null;) {        if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {            for (;;) {                Thread t = q.thread;                if (t != null) {                    q.thread = null;                    LockSupport.unpark(t);                }                WaitNode next = q.next;                if (next == null)                    break;                q.next = null; // unlink to help gc                q = next;            }            break;        }    }    done();    callable = null;        // to reduce footprint}

1、执行FutureTask类的get方法时，会把主线程封装成WaitNode节点并保存在waiters链表中；
2、FutureTask任务执行完成后，通过UNSAFE设置waiters的值，并通过LockSupport类unpark方法唤醒主线程；