线程池运行原理以及参数解析（线程池的工作原理,几个重要参数?）

//核心线程数，也就是线程中常保持活跃的线程数量。
private volatile int corePoolSize;
//是否允许核心线程超过一定时间后销毁
private volatile boolean allowCoreThreadTimeOut;
//当允许核心线程销毁后，核心线程存活的时间。
private volatile long keepAliveTime;
//最大线程数，超过最大线程后，将会被线程池拒绝
private volatile int maximumPoolSize;
//用于存放任务的队列,当需要执行的线程数量超过核心线程后，线程需要进入到此队列等待，LinkedBlockingQueue
private final BlockingQueue<Runnable> workQueue;
//创建线程的工厂
private volatile ThreadFactory threadFactory;
//拒绝策略，默认：AbortPolicy
private volatile RejectedExecutionHandler handler;
//这个就是线程中的核心线程，只不过被封装成了Worker类，内部使用threadFactory创建线程
private final HashSet<Worker> workers = new HashSet<>();

上面说的是线程池中的几个核心参数，也是面试中常问的几个参数，下面是当使用线程池执行时的代码逻辑，通过阅读代码，我们可以看到线程池执行的具体逻辑

public void execute(Runnable command) {
  	//这里就是传入的线程任务
    if (command == null)
        throw new NullPointerException();
   	//当前线程池线程的数量
    int c = ctl.get();
  	//1、如果线程池中运行的线程少于corePoolSize，尝试以给定的命令作为第一个命令启动一个新线程
  	//只要工作线程数小于核心线程数，不管工作线程是否有空，都会直接创建工作线程并直接任务。
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
  	//2、如果线程数量超过核心线程数量，则尝试排队。
  	//如果任务可以成功排队，那么仍然需要仔细检查我们是否应该添加一个线程（因为自上次检查以来已有的死亡）或池在进入此方法后关闭。所以我们重新检查状态，如有必要，回滚排队已停止，或者启动一个新线程（如果没有）
    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);
    }
  	//3、线程队列已经满了，需要先判断是否超过maximumPoolSize最大线程数，没超过则创建非核心线程
  	//4、是的话，则开始执行拒绝策略
    else if (!addWorker(command, false))
      	//拒绝策略
        reject(command);
}

//这里面不仅包含了线程是如何被执行的，还包含了创建线程的逻辑
private boolean addWorker(Runnable firstTask, boolean core) {
    for (int c = ctl.get();;) {
        		...
            for (;;) {
              	//判断线程是否超过了corePoolSize或者maximumPoolSize，如果超过了，则返回false，然后执行拒绝策略
                if (workerCountOf(c)
                    >= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
                    return false;
                ...
            }
        }
    boolean workerStarted = false;
    boolean workerAdded = false;
    ThreadPoolExecutor.Worker w = null;
    try {
       	//创建Worker线程
      	//在Worker里面的线程是通过我们最开始传入的线程工厂创建的
        w = new Worker(firstTask);
        final Thread t = w.thread;
       ... //这里省略其他逻辑
       workers.add(w);
       workerAdded = true;
       if (workerAdded) {
          // 2. 启动线程, 这里的start() 就是线程启动，我们看Worker类里面把this传递给thread了
          // 所以这里start()其实调用的是 Worker里面的 run() 方法。
          t.start();
          workerStarted = true;
        }
       ...
    return workerStarted;
}

//单个线程信息
class Worker extends AbstractQueuedSynchronizer implements Runnable
    // Worker类的构造方法, 并且Worker是 实现的 Runnable接口
    Worker(Runnable firstTask) {
        this.firstTask = firstTask;
        // 这里其实 <=> this.thread = new Thread(this);
        this.thread = getThreadFactory().newThread(this);
    }
   // 3. 接着上面第2步 start() 方法过来
   public void run() {
      runWorker(this);
  }
   final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
       // 4. 拿到真正的任务
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
           // 5. 这里如果task为null, 就从 队列里面循环获取，这里就是通过 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 {
                    try {
                       // 6. 启动任务
                        task.run();
                    } catch (Throwable ex) {
                        throw ex;
                    }
                } finally {
                    task = null;
                    w.unlock();
                }
            }
           // 工作线程中断或者异常跳出，会触发Worker线程回收工作
            completedAbruptly = false;
        } finally {
           // 释放Worker线程
            processWorkerExit(w, completedAbruptly);
        }
    }
}

关于线程池的运行过程，我画了一张关于线程池运行过程的图，图中详细说明了从任务提交到执行结束，线程池都做了什么。