Java线程池的原理

先上个网图说明下线程池的执行过程

image.png

来看下线程池的执行过程

image.png
1.当线程池数量小于核心线程数 直接创建核心线程
2.队列是否已满，没有的话 放入队列

3.放入队列失败 添加非核心线程 失败的话 处理失败

很容易看出核心方法是addWork 这个方法是添加线程执行的，不做过多解释。
在这个方法中调用了 start 方法，这个很熟悉是启动线程的方法。
顺藤破瓜看看Work的run方法 只有一个runWork方法

 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()核心线程）
            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 {
            processWorkerExit(w, completedAbruptly);
        }
    }

重点是 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 ?
                    // 非核心线程超过时间会被淘汰 返回null 退出线程
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                   // 小于核心线程，当前待线程为0  阻塞线程保证默认情况下的核心线程不会销毁
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

大体意思就是
不停的取task
超时退出线程
没有任务时 阻塞线程 可以设置核心线程可以退出，这个时候线程不会阻塞