java-源码解读-线程池实现原理-0

最新推荐文章于 2024-01-03 18:25:51 发布

aBOUNTWINTER

最新推荐文章于 2024-01-03 18:25:51 发布

阅读量601

点赞数 4

分类专栏： JAVA

本文链接：https://blog.csdn.net/abountwinter/article/details/77265600

版权

JAVA 专栏收录该内容

28 篇文章 1 订阅

订阅专栏

线程池初识

我们一般这样使用线程池：

public class ExecutorServiceDemo {  
     public static void main(String[] args) {  
      // 创建一个线程池对象，控制要创建几个线程对象。  
      ExecutorService pool = Executors.newFixedThreadPool(2);  
      // 可以执行Runnable对象或者Callable对象代表的线程  
      List<FutureTask> futures=new ArrayList<FutureTask>();  
      for(int i=0;i<n;i++){  
        FutureTask future=pool.submit(new MyRunnable());  
        futures.add(future);  
      }  
     //线程池不接收新的任务  
     pool.shutdown();  
     //做一些别的事情  
     //...  
  
     //获取结果  
     //future.get()  
    }  
 }

首先获取一个线程池，获取的方法可以用Executors工具类，也可以是别的方法，然后向线程池中提交任务，然后获取结果。

深入线程池

线程的状态和工作线程个数

线程池用ctl变量表示线程池的状态和工作线程数

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

从这里也可以看出线程池的初始状态为RUNNING

ctl的高三位表示线程池的状态，低29位表示工作线程的个数。
private static final int COUNT_BITS = Integer.SIZE - 3; //count为低29位表示

线程池的状态
// runState is stored in the high-order bits 线程池用ctl高三位表示状态

private static final int RUNNING = -1 << COUNT_BITS;

转成二进制为：RUNNING = 111 xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

private static final int SHUTDOWN = 0 << COUNT_BITS;

转成二进制为：SHUTDOWN = 000 xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

private static final int STOP = 1 << COUNT_BITS;
转成二进制为：STOP = 001 xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

private static final int TIDYING = 2 << COUNT_BITS;
转成二进制为：TIDYING = 010 xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

private static final int TERMINATED = 3 << COUNT_BITS;
转成二进制为：TERMINATED = 011 xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

线程池的容量
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
转成二进制为：CAPACITY = 000 11111111111111111111111111111

构建线程池的成员
/**线程池工厂，用于创建线程**/
private volatile ThreadFactory threadFactory;
/**拒绝策略**/
private volatile RejectedExecutionHandler handler;
/**线程空闲时存活时间**/
private volatile long keepAliveTime;
/**是否允许线程空闲**/
private volatile boolean allowCoreThreadTimeOut;
/**core pool size**/
private volatile int corePoolSize;
/**max pool size**/
private volatile int maximumPoolSize;
/**默认的拒绝策略为放弃**/
private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();

构建线程池

用线程池工具类Executors

ExecutorService servcie=Executors.newFixedThreadPool(..),

ExecutorService servcie=Executors.newCachedThreadPool(..)

...

调用构造方法构造线程池

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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

上面两种，其实都是最后都是调用了ThreadPoolExecutor的构造方法

提交任务的时候发生了什么

不管是用ThreadPoolExecutor.execute()提交，还是用ExecutorService的submit方法提交，最终都会调用execute方法。

(execute方法提交和subit提交有何不同呢，请参考我的另一遍博客：java-源码解读-线程池提交之execute和submit有何不同)

 public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);  //此处还是调用了execute方法提交
        return ftask;
 }

开始提交任务

   /**execute方法提交任务**/
    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        //获取活动线程数和线程池状态，这两步是一个原子操作，通过获取ctl同时获取（高3位是状态位低29位是活动线程数），
        int c = ctl.get();
        /**A:如果活动线程数小于corePoolSize就创建一个新的线程来执行任务**/
        if (workerCountOf(c) < corePoolSize) {
             /**addWorker方法创建一个新的线程**/
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        /**B:如果活动线程数>=corePoolSize程池没关闭，就把任务加入到工作队列中**/ 
     if (isRunning(c) && workQueue.offer(command)) {
            /**重新获取ctl,线程池的状态有可能又变了，或者有一个线程已执行完**/
            int recheck = ctl.get();
            /**recheck ,把command加入queue后,有可能有worker died**/
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0) /**没有工作线程**/
                /**如果此时线程池已经关闭了，但已经没有工作线程了，
                就提交一个空任务，然后创建一个线程执行队列的任务，
                addWorker方法中会判断线程池的状态，
                添加一个null任务是因为SHUTDOWN状态下，线程池不再接受新任务**/
                addWorker(null, false);
        }
        /**如果AB两步都失败了,即此时工作线程数>corePoolSize,然后加入队列也失败了，此时就只有增加一个新的线程来执行了**/
        /**这个时候有两种情况：
         1.非RUNNING状态拒绝新的任务
          2.队列满了workCount < maximumPoolSize（addWorker方法中会有判断），注：此时addWorker的参数为false
        **/
        else if (!addWorker(command, false))
            /**如果还失败就执行拒绝策略**/
            reject(command);
    }

从上面可以看出：

A:如果活动线程数小于corePoolSize就创建一个新的线程来执行任务

B:如果addWorker失败了,大部分原因是workerCountOf(c)>=corePoolSize，且线程池没关闭，就把任务加入到工作队列中

C:如果AB都失败，即 maxpoolsize>工作线程>corepoolSize,就只有创建一个新的线程来运行任务

工作线程是怎样运行起来

  
    /**创建新的线程(Worker)执行Runnable,只有添加空任务时 core=false**/
    private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            /**状态检查，状态为SHUTDOWN的就不能添加新任务了
            但此处为first==null(空)任务开了绿灯，
            当rs>=SHUTDOWN,firtTask==null workQueue.isEmpty==false时,不会return false ,而是继续执行下面的逻辑
            **/
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;
            for (;;) {
                //判断当前的工作线程数
                int wc = workerCountOf(c);
                //只有添加空任务时 core=false
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                    //CAS操作使workcount+1,成功了下跳出retry,失败了就继续retry
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                //如果CAS失败了，可能线程池的状态又变了，继续retry
                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,Worker中有Thread 成员变量，用来运行任务
            w = new Worker(firstTask);
            //t:Worker 中的线程
            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用来存放工作的线程
                        workers.add(w);
                        int s = workers.size();
                        //largestPoolSize只是作了记录而以
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    //工作线程启动了，这里启动了Worker，下面会看Worker的run方法里都有什么
                    t.start();
                    //标识任务已经起动了
                    workerStarted = true;
                }
            }
        } finally {
            //任务没有启动成功，有可能是线程池关闭了...要回滚，addWorkerFailed作一些回滚操作
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

提交的任务以及队列中的任务何时调用

    下面看最重要的Worker
   //首行worker是一个线程
     private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
        //用来运行任务的线程
        final Thread thread;
        //要运行的任务
        Runnable firstTask;
        //已完成的任务
        volatile long completedTasks;
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }
        //在这里运行任务
        public void run() {
            runWorker(this);
        }
        
     //在这里运行任务
     final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            //空任务是不会运行的，getTask()方法会用到线程池的两个变量keepAliveTime，allowCoreThreadTimeOut，后面讲
            //取一个任务运行，这个任务有可能是刚刚提交的任务，也有可能是从队列中取的任务
            //但是刚提交的任务会优先运行，如果没有提交的任务（或提交的为空任务），才调用getTask()从队列中取任务
            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 {
                        //这是一个空的回调方法
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            //没有取到任务
            completedAbruptly = false;
        } finally {
            //没有取到任务，worker要退出了
            processWorkerExit(w, completedAbruptly);
        }
    }
   
    //getTask()方法从列队中取任务，用到线程池的两个变量keepAliveTime，allowCoreThreadTimeOut
     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 {
            //在keepAliveTime时间内取到一个任务就返回
             //从队列中取任务
               Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }
    }

从上面可以看出Worker的run方法一直在取任务，然后运行任务。如果在keepAliveTime时间内还没有取到任务，线程可能就要退出了

aBOUNTWINTER

关注

4
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
java-源码解读-线程池实现原理-0

线程池初识我们一般这样使用线程池：public class ExecutorServiceDemo { public static void main(String[] args) { // 创建一个线程池对象，控制要创建几个线程对象。 ExecutorService pool = Executors.newFixedThreadPool(2); ...
复制链接

扫一扫