Java线程池:ThreadPoolExecutor源码分析

用过java线程的同学都应该大致了解,在java中,为了合理使用线程以合理利用资源、提高吞吐率以及加快响应时间,通常会使用java线程池,因为线程池架构设计合理,比起自己创建线程可能花销巨大来讲,线程池是一个很好的选择。

作为一只喜欢研究源码的程序猿,就我所学,来讲讲java线程池是如何巩工作的。

一.4种线程池

首先,java线程池为我们量身定制了4中拿来即用的线程池:

1.newSingleThreadExecutor:

public static ExecutorServicenewSingleThreadExecutor() {

            return new FinalizableDelegatedExecutorService

                   (new ThreadPoolExecutor(1, 1,

                                0L, TimeUnit.MILLISECONDS,

                                new LinkedBlockingQueue()));

}


2.newFixedThreadPool:

public static ExecutorServicenewFixedThreadPool(int nThreads) {

            return new ThreadPoolExecutor(nThreads, nThreads,

                                  0L, TimeUnit.MILLISECONDS,

                                  new LinkedBlockingQueue());

}

3.newCachedThreadPool:

public static ExecutorServicenewCachedThreadPool() {

            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

                                  60L, TimeUnit.SECONDS,

                                  new SynchronousQueue());

}

4. newScheduledThreadPool:

public static ScheduledExecutorServicenewSingleThreadScheduledExecutor() {

            return new DelegatedScheduledExecutorService

                        (new ScheduledThreadPoolExecutor(1));

}

可以发现:除了newScheduledThreadPool,其他三个都是ThreadPoolExecutor的一种特殊实现。

二.ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,

                          int maximumPoolSize,

                          long keepAliveTime,

                          TimeUnit unit,

                          BlockingQueue 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;

}

1.构造函数参数说明:

1).corePoolSize:线程池中的核心线程数

2).maximumPoolSize:线程池中的最大线程数

3).keepAliveTime: 线程池中的线程的存活时间

4).unit: keepAliveTime的时间单位

5).workQueue: BlockingQueue的实现,用于存储任务

6).threadFactory:自定义线程的创建工厂

7).handler:线程池的饱和策略,当阻塞队列满了,且没有空闲的线程,继续提交任务时,必须进行处理,默认的方式是抛出RejectedExecutionHandler异常

2.内部状态变量说明:

jdk1.8就是用一个int型来表示线程池的运行状态和运行任务数量,一个int一共32位,前3位表示运行状态,后29位表示运行任务线程数;运行状态和运行任务线程数量分别通过runStateOf(int c)和workerCountOf(int c)来获取,都是通过&操作来计算的。各个值的初始值分为如下:

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;

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

 1).ctl:包装任务状态和线程数(高3位表示运行状态,后29位表示运行任务线程数),初始值:11100000000000000000000000000000,没多一线程就加1,为原子操作;默认AtomicInteger,如果数量不够的话,可以自行改成AtomicLong

  2).COUNT_BITS:29

  3).CAPACITY:运行任务线程数,值为:000 11111111111111111111111111111

  4).RUNNING:运行状态,       值为:111 00000000000000000000000000000

  5).SHUTDOWN:关闭状态,  值为:0

  6).STOP: 停止状态,             值为:001 00000000000000000000000000000

  7).TIDYING:整理状态,         值为:010 00000000000000000000000000000

  8).TERMINATED:终止状态,值为:011 00000000000000000000000000000

3.内部公用函数说明:

1).runStateOf(int c):获取运行状态,

2).workerCountOf(int c):获取运行任务线程数

3).ctl(int rs,int wc): 包装运行状态和任务线程数

4).runStateLessThan(int c,int s):是否小于某个状态

5).runStateAtLesat(int c,int s):是否大于或者等于某个状态

这些公共函数接下来都会用到,写在这里是便于理解。

4.提交任务函数:execute(Runnable command)

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).如果当前运行任务线程数小于corePoolSize,尝试另起线程去运行任务。调用addWorker函数会自动检查运行状态和运行任务线程数,防止添加线程时出现多线程操作错误。

2).如果添加新的线程失败,那么就将该任务添加到队列中,同时,还需要检查运行状态和运行任务线程数;再次检查状态,防止入列期间出现状态改变情况,如果线程池处于非运行状态,移除任务;如果没有运行任务线程数量为0,则起一个新的线程。

3).如果任务不能进入队列(例如队列满了),再次尝试另起一个线程运行;如果失败了,使用拒绝策略。

5.addWorker

在execute函数中,addWorker是另起线程去执行任务,它的具体实现如下:

private boolean addWorker(Runnable firstTask, boolean core) {

    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           }

    }

    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;

}


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值