天天看點

線程池細節詳解ThreadPoolExecutor

關于線程池的幾個參數的含義,我們就不多說了,下面我們通過源碼看下這幾個參數分别是在什麼地方使用到的:

核心池大小與最大池大小是在執行任務的時候用到的,這裡我們不多說。

當線程池中沒有任務,線程池就會維持核心池大小的線程,這個源碼如下:

當線程進來會先被封裝成一個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);
        }

        /** Delegates main run loop to outer runWorker  */
        public void run() {
            runWorker(this);
        }
           

實際上,線程池建立的線程,是先執行的這個Worker類的run方法,然後才執行Runnable類的run方法,即為封裝了一層,如下:

Runnable task = w.firstTask;      
task.run();      
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) {
           

runWorker中有一個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;
            }
        }
    }
           

上面可以看到,如果目前線程數(wc>corePoolSize)的話,則執行阻塞隊列的poll方法,否則執行take()方法,而poll方法中,傳入了一個keepAliveTIme的參數,此時空閑線程會等keepalive的時間,如果取不到資料則傳回空,目前線程走完結束,如果執行take()方法,則會一直阻塞,知道取到資料,這就是為什麼核心線程池一直存在的原因。

同時我們還看到一個allowCoreThreadTimeOut參數,這個參數預設值是false,如果不想讓核心線程存在也可以主動将此參數設定為true。

另外還有一個可以說下的就i是ThreadFactory,它建立線程的方式跟我們平時建立線程用的方式是一樣的:

this.thread = getThreadFactory().newThread(this);      
public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
           

也就是new了一個線程這樣而已。ThreadFactory隻是建立線程用的,線上程建立好後,就跟ThreadFactory完全沒有關系了。

繼續閱讀