ThreadPoolExecutor 的理解

公司有位大佬写下这么一段话

 

①，FixedThreadPool任务队列的无边界会致使内存溢出以及高延迟
②，CachedThreadPool线程数的无边界会致使并发高的时候建立的线程数不可控

建议由于二者都不是特别友好，因此推荐直接使用ThreadPoolExecutor，它提供了不少参数能够进行细粒度的控制，

而后我就找了个机会了解下，这是怎么回事

查看ThreadPoolExecutor#execute 方法

简介说，这可能启动新的线程或原有线程开启任务或拒绝任务，代码以下

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();        
        int c = ctl.get();
//如何工做的线程数小于核心线程数
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))//新起一个线程并添加到工做队列,而后return
                return;
            c = ctl.get();
        }
        //workQueue.offer将任务添加到工做队列中
        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，当执行线程数小于核心线程数或阻塞队列满的时候，会尝试直接开启一线程运行任务：addWorker

new Worker 会从线程池中获取新的线程，并保存到一个实例变量中，以下

Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
//记录好第一个任务
            this.firstTask = firstTask;
//这里实现线程的重用
            this.thread = getThreadFactory().newThread(this);
        }

线程运行时流程worker.t.start->worker#run->ThreadPoolExecutor#runWorker

会一直从workQueue取出任务，当workQueue为空时，则阻塞获取

2，当执行线程数大于等于核心线程数时，将任务添加到阻塞队列：workQueue.offer(command)

 work工做时会运行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 {
            //不断从工做队列中获取task，并执行，这就是所谓的线程池和工做窃取机制
            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);
        }
    }