Executor框架源码详解和线程池的实现原理

最新推荐文章于 2022-04-11 16:01:52 发布

sword man

最新推荐文章于 2022-04-11 16:01:52 发布

阅读量361

点赞数

分类专栏： Java 文章标签： java线程池实现原理 Executor框架线程池种类线程池状态

本文链接：https://blog.csdn.net/qq_37447414/article/details/84330363

版权

Java 专栏收录该内容

10 篇文章 1 订阅

订阅专栏

Executor框架简介

JDK1.5引入的Excutor框架对线程任务的提交和执行进行了解耦，只需定义好任务，然后交给线程池就好啦。

什么是线程池

Sun公司在JDK1.5对线程的类库做了很大的扩展，增加了许多新特性，例如引进了Excutor框架和线程池。
线程池的基本思想是对象池的思想，即开辟一个空间，里面存放了许多线程（未死亡的）；池中的线程由池管理器管理，当有线程任务时，直接交给线程池，不用关心该任务是如何执行、被哪个线程执行、何时执行。
假设一个线程任务从执行到结束分为以下时间段：t1 线程创建时间 t2 线程执行时间 t3线程销毁时间；当t1+t3>t2时就可以使用线程池。
合理使用线程池对线程进行统一分配、调优和监控主要有以下好处：

降低资源消耗
提高响应速度
提高线程的可管理性

Executor框架图

在这里插入图片描述

Executor接口

public interface Executor {
    void execute(Runnable command);
}

Executor接口是Executor框架最基础的部分，它只定义了一个excute()方法用来执行Runable。它没有实现类，只有一个子接口ExecutoService。

ExcecutorService接口

//继承Excutor接口
public interface ExecutorService extends Executor {
	/**
	*关闭方法。调用该方法后线程池执行之前提交的任务，不再接受新任务
	*/
    void shutdown();
    /**
    *试图停止正在执行的任务，返回等待执行的任务列表
     */
    List<Runnable> shutdownNow();

    /**
     *判断线程池是否关闭
     */
    boolean isShutdown();

    /**
    *线程池关闭后判断所有任务是否完成
    /*
    boolean isTerminated();

    /**
    请求关闭、发生超时或者当前线程中断，无论哪一个发生都将导致阻塞，直到所有的任务都被执行完毕
    *timeout:最长等待时间 unit时间单位
    */
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
   *提交一个Callable任务，用Future.get()获得结果并返回来接受结果
     */
    <T> Future<T> submit(Callable<T> task);

    /**
    *提交一个Callable任务，用Future.get()获得结果，用result接受结果
     */
    <T> Future<T> submit(Runnable task, T result);

    /**
     *提交一个callable任务，返回一个用于表示该任务的Future,如果该任务成功执行完成，Future.get()返回null。
     */
    Future<?> submit(Runnable task);

    /**
     *执行给定的任务，当任务完成后返回表示任务状态和任务结果的列表，返回列表的所有元素的Future.isDone()为True,可以通过正常或者抛出异常来终止已经完成的任务，如果在执行过程中Collection发生改变， 则该方法的返回结果是不确定的。
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    /**
    *执行给定的任务，当任务完成或者超时期满返回表示任务状态和返回结果的列表，返回列表的所有元素Future.isDone()为true.可以通过正常或者抛出异常来终止已经完成的任务，如果在执行过程中Collection发生改变， 则该方法的返回结果是不确定的。
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
    *执行给定的任务，如果某个任务完成的话，则返回其结果，如果返回（正常或者异常表返回）则取消尚未完成的任务，在执行的过程中，如果Collection发生改变则返回结果是不确定的。
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    /**
    *执行给定的任务，如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果。一旦正常或异常返回后，则取消尚未完成的任务。如果此操作正在进行时修改了给定的 collection，则此方法的结果是不确定的。
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

ThreadPoolExecutor

public class ThreadPoolExecutor extends AbstractExecutorService

ThreadPoolExcutor类继承了AbstractExcutorService,是一个线程池管理类

线程池内部状态(5种)

 private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    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
    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;

ctl:利用高三位表示线程池的运行状态，低29位表示线程池中的线程数

RUNNING： 该状态的线程池会接受新的任务并处理阻塞队列中的任务；线程池的初始化状态是RUNNING;线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0
SHUTDOWN： 该状态的线程池不会接受新的任务，但是会处理阻塞队列中任务。调用线程池的接口shutdown()时，线程池就会：RUNNING->SHUTDOWN
STOP： 该状态下的线程池既不接受新的任务也不处理阻塞队列中的任务，而且还会终止正在执行的任务。调用线程池接口shutdownNow()时，线程池就会：RUNNING/SHUTDOWN->STOP
TIDYING： 当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。线程池在SHUTDOWN状态下，如果阻塞队列为空并且正在执行的任务为空，则该线程池：SHUTDOWN->TIDYING;线程池在
TERMINATED： 线程池彻底终止时就进入了该状态。线程池在TIDYING状态时执行terminated()后就进入了TERMINATED状态。

private volatile int corePoolSize;

线程池中的核心线程数，每当提交给线程池一个线程任务时，线程池就会创建一个线程来执行该线程任务，直到当前线程数等于核心线程数时，继续提交来的任务就会被保存到阻塞队列中。如果执行了prestartAllCoreThreads()，线程池会提前创建并启动所有核心线程。

 private volatile int maximumPoolSize;

线程池能容纳的最多线程数，当有线程任务提交时发现阻塞队列已经满了，此时线程池会创建新的线程来执行该任务，但是前提是当前线程数小于maximumPoolSize。

private volatile long keepAliveTime;

线程空闲时的存活时间，就是线程没有任务执行时的继续存活时间。一般来说该参数只在当前线程数大于核心线程数时才有效。

unit

KeepAliveTime的时间单位

private final BlockingQueue<Runnable> workQueue;

用来保存待执行任务的阻塞队列，且该任务必须要实现Runnable接口，jdk主要提供以下几种阻塞队列：

ArrayBlockingQueue : 基于数组结构的有界阻塞队列，按照FIFO排序任务
LinkedBlockingQueue: 基于链表结构的阻塞队列，按照FIFO排序任务，吞吐率大于ArrayBlockingQueue.
SynchronousQueue: 不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞吞吐率高于LinkedBlockingQueue。
priorityBlockingQueue: 具有优先级的无界阻塞队列

private volatile ThreadFactory threadFactory;
类DefaultThreadFactory实现了接口ThreadFactory
DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }

创建线程的工厂，通过自定义的线程工厂给创建出来的线程设置一个具有识别度的线程名。

private volatile RejectedExecutionHandler handler;

线程池的饱和策略，当阻塞队列满了以后，再有任务提交来时，需要采取一定的策略来处理该任务。线程池提供了四种策略：

AbortPlicy 直接抛出异常，线程池的默认策略
CallerRunsPolicy 用调用者所在的线程来执行任务
DiscardOldersPolicy 丢弃阻塞队列中最靠前的任务，并执行当前任务
DiscardPolicy 直接丢弃当前任务

Excutors

是一个用来创建线程池的类，线程池的种类与Excutors的构造方法有关，主要有以下四种：

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

初始化一个指定线程数的线程池，使用LinkedBlockingQueue作为阻塞队列，当线程池没有可执行任务时也不会释放线程。

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

创建一个可以缓存线程的线程池，默认缓存60s,线程池的线程数可达Integer.MAX_VALUE即2147483647个，内部使用SynchronousQueue作为阻塞队列。
与newFixedThreadPool创建的线程池有所不同，用newCachedThreadPool创建的线程池，当其中的线程没有任务可执行后，空闲时间达到keepAliveTime
时，会释放掉该线程资源；当有新任务提交时，如果没有空闲线程，会创建新的线程，这就会导致一定的系统开销。所以使用该线程池时要注意并发的任务数，否则创建的大量的线程会造成性能问题。

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

创建只有一个线程的线程池，如果线程池的线程异常结束会创建一个新的线程继续执行任务，唯一的线程可以保证提交的任务顺序完成；内部使用LinkedBlockingQueue作为阻塞队列。

public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }

创建的线程池可以周期性的执行所提交的任务，在实际应用中主要用来同步数据。
小结
以上四种线程池除了newScheduledThreadPool都是基于ThreadPoolExcutors实现的。

任务提交

Excutor框架提供了两种方式来提交任务，根据不同的需求来选取

Executor.execute()

public interface Executor {

    void execute(Runnable command);
}

通过该方法提交的任务必须要实现Runnable接口，而且不能获得返回值，因此无法判断是否执行成功

EexcutorService.submit()

Future<T> submit(Runnable task, T result);

通过该方法提交的任务，在任务执行完后可以获取返回值

任务执行

当一个任务提交给线程池后，线程池会如何来处理该任务？

通过 Executor.execute()提交的任务执行过程

execute的实现源码(ThreadPoolExecutor.execute())

 public void execute(Runnable command) {
        if (command == null)//判断当前提交的任务是否为空
            throw new NullPointerException();
        
        int c = ctl.get();//得到ctl的值
    1. if (workerCountOf(c) < corePoolSize) {//workerCountof可以由ctl的值获取ctl低二十九位的值。判断ctl的低二十九位的值即当前线程数是否小于核心线程数，判断条件不成立的话执行2.
            if (addWorker(command, true))//如果当前线程数小于核心线程数则调用addWorker方法创建新的线程执行任务
                return;
            c = ctl.get();
        }
   2.  if (isRunning(c) && workQueue.offer(command)) {//判断当前线程池是否处于RUNNING状态并且是否成功将任务添加到阻塞队列，判断条件不成立的话执行3.
            int recheck = ctl.get();//再次获得ctl的值
            if (! isRunning(recheck) && remove(command))//再次检查线程池是否处于RUNNING状态并且是否成功将提交的任务从阻塞队列中删除
                reject(command);//上述条件成立的话调用该方法处理任务
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
      3.  else if (!addWorker(command, false))//执行addWorker方法创建线程执行任务，如果addWorker执行失败则调用reject方法处理任务
            reject(command);
    }
```java
#### addWorker实现源码(ThreadPoolExecutor.addWorker())
由execute的源码我们可知addWorker方法主要是创建线程并执行任务，其源码实现如下：

```java
 private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();//获取ctl值
            int rs = runStateOf(c);//获取ctl的高三位值即当前线程池的状态值
            if (rs >= SHUTDOWN &&//如果当前线程池的状态值大于或者等于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;
               
            }
        }
//下面是创建线程的过程
        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;
    }

线程池的工作线程是通过worker类实现的，在ReentrantLock锁的保证下，把Worker类的实现插入到HashSet中，并启动Worker中的线程。

Worker(ThreadPoolExecutor的内部类)

Worker类继承了AbstractQueuedSynchronizer以便实现工作线程的终止操作
实现了Rnnable接口，因此可以将自己作为一个任务在工作线程中执行
当前提交的任务firsttask作为参数传入构造方法中

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);
        }

从Worker的构造方法里面可以看出，线程工厂在创建线程时，将Worker实例本身作为参数传入，当执行start方法启动线程时，其实是调用Worker中的runWorker方法。

runWorker源码实现（ThreadPoolExecutor.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 ((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 {
                        b(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

runWorker是线程池的核心：

线程启动后通过unlock释放锁，并进行中断
获取第一个任务firstTask,执行任务的run方法，在执行run前加锁，执行完后释放锁。
根据业务需求自定义beforeExecute afterExecute方法
fistTask任务执行完后通过getTask方法来获取阻塞队列中的任务，如果阻塞对了中无任务，则getTask方法将被挂起，不会占用cpu资源。

getTask源码实现（ThtreadPoolExecutor.getTask()）

private Runnable getTask() {
        boolean timedOut = false; 
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }
            int wc = workerCountOf(c);
            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;
            }
        }
    }

整个getTask操作在一个无限循环中实现：

workQueue.take: 如果当前阻塞队列为空，则当前线程会被挂起，当队列中有任务提交来时，线程会被唤醒，take方法返回任务并执行。
workQueue.poll： 如果阻塞队列在keepAliveTime时间段内还是没有任务，则返回null.

综上，线程池中的线程可以一直执行用户提交的任务

通过 ExecutorService.submit()提交的任务执行过程

submit的实现源码(AbstractExecutorService.submit)

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

通过源码我们可以发现，通过submit提交的Callable任务被封装成一个Futuretask对象。

类FutureTask部分源码

public class FutureTask<V> implements RunnableFuture<V> 
 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;

FutureTask在不同时期有不同状态，初始化为NEW
FutureTask实现了Runnable接口，因此可以通过Excutor.execute()方法提交FutureTask到线程池被执行。在线程池被执行的时候是执行FutureTask.run()方法。

FutureTask.run()实现源码

public void run() {
//如果当前不是new状态，或者当前cas设置当前线程失败则返回
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
        //当前状态为new 则调用任务的call方法执行任务
            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);完成NEW -> COMPLETING -> EXCEPTIONAL 状态转移
                }
                //执行任务成功则保存结果更新状态，unpark所有等待线程。
                if (ran)
                    set(result);
            }
        } finally {
            runner = null;
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

FutureTask.run方法是在线程池中被执行的，而非主线程
1、通过执行Callable任务的call方法；
2、如果call执行成功，则通过set方法保存结果；
3、如果call执行有异常，则通过setException保存异常；

任务提交后会通过FutureTask.get方法来获取结果

FutureTask.get实现源码

 public V get() throws InterruptedException, ExecutionException {
        int s = state;
        //如果当前状态是new或者COMPLETING则等待，因为位normal或者exceptional时候才说明数据计算完成了。
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }

由源码可知FutureTask.get内部是通过awaitDone对主线程进行阻塞

FutureTask.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();
            }
	//判断FutureTask当前的state，如果大于COMPLETING，说明任务已经执行完成，则直接返回；
            int s = state;
            if (s > COMPLETING) {
                if (q != null)
                    q.thread = null;
                return s;
            }
            // 如果当前state等于COMPLETING，说明任务已经执行完，这时主线程只需通过yield方法让出cpu资源，等待state变成NORMAL；
            else if (s == COMPLETING) 
                Thread.yield();
            else if (q == null)
                q = new WaitNode();
            else if (!queued)通过WaitNode类封装当前线程，并通过UNSAFE添加到waiters链表；
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                     q.next = waiters, q);
            else if (timed) {
                nanos = deadline - System.nanoTime();
                //超时则返回
                if (nanos <= 0L) {
                    removeWaiter(q);
                    return state;
                }
                 //否者设置park超时时间
                LockSupport.parkNanos(this, nanos);
            }
            else
//直接挂起当前线程
                LockSupport.park(this);
        }
    }

FutureTask.set实现源码

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

FutureTask.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方法通知主线程任务已经执行完成

FutureTask.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方法唤醒主线程；
参考文章：
深入分析java线程池的实现原理
 FutureTask 原理