看两段源码：
1 public ThreadPoolExecutor(int corePoolSize, 2 3 int maximumPoolSize, 4 5 long keepAliveTime, 6 7 TimeUnit unit, 8 9 BlockingQueue<Runnable> workQueue, 10 11 ThreadFactory threadFactory, 12 13 RejectedExecutionHandler handler) { 14 15 if (corePoolSize < 0 || 16 17 maximumPoolSize <= 0 || 18 19 maximumPoolSize < corePoolSize || 20 21 keepAliveTime < 0) 22 23 throw new IllegalArgumentException(); 24 25 if (workQueue == null || threadFactory == null || handler == null) 26 27 throw new NullPointerException(); 28 29 this.acc = System.getSecurityManager() == null ? 30 31 null : 32 33 AccessController.getContext(); 34 35 this.corePoolSize = corePoolSize; 36 37 this.maximumPoolSize = maximumPoolSize; 38 39 this.workQueue = workQueue; 40 41 this.keepAliveTime = unit.toNanos(keepAliveTime); 42 43 this.threadFactory = threadFactory; 44 45 this.handler = handler; 46 47 } 48 49 private boolean addWorker(Runnable firstTask, boolean core) { 50 51 retry: 52 53 for (;;) { 54 55 int c = ctl.get(); 56 57 int rs = runStateOf(c); 58 59 // Check if queue empty only if necessary. 60 61 if (rs >= SHUTDOWN && 62 63 ! (rs == SHUTDOWN && 64 65 firstTask == null && 66 67 ! workQueue.isEmpty())) 68 69 return false; 70 71 for (;;) { 72 73 int wc = workerCountOf(c); 74 75 if (wc >= CAPACITY || 76 77 wc >= (core ? corePoolSize : maximumPoolSize)) 78 79 return false; 80 81 if (compareAndIncrementWorkerCount(c)) 82 83 break retry; 84 85 c = ctl.get(); // Re-read ctl 86 87 if (runStateOf(c) != rs) 88 89 continue retry; 90 91 // else CAS failed due to workerCount change; retry inner loop 92 93 } 94 95 } 96 97 boolean workerStarted = false; 98 99 boolean workerAdded = false; 100 101 Worker w = null; 102 103 try { 104 105 w = new Worker(firstTask); 106 107 final Thread t = w.thread; 108 109 if (t != null) { 110 111 final ReentrantLock mainLock = this.mainLock; 112 113 mainLock.lock(); 114 115 try { 116 117 // Recheck while holding lock. 118 119 // Back out on ThreadFactory failure or if 120 121 // shut down before lock acquired. 122 123 int rs = runStateOf(ctl.get()); 124 125 if (rs < SHUTDOWN || 126 127 (rs == SHUTDOWN && firstTask == null)) { 128 129 if (t.isAlive()) // precheck that t is startable 130 131 throw new IllegalThreadStateException(); 132 133 workers.add(w); 134 135 int s = workers.size(); 136 137 if (s > largestPoolSize) 138 139 largestPoolSize = s; 140 141 workerAdded = true; 142 143 } 144 145 } finally { 146 147 mainLock.unlock(); 148 149 } 150 151 if (workerAdded) { 152 153 t.start(); 154 155 workerStarted = true; 156 157 } 158 159 } 160 161 } finally { 162 163 if (! workerStarted) 164 165 addWorkerFailed(w); 166 167 } 168 169 return workerStarted; 170 171 }
以上可以看出，ThreadPoolExecutor的主要参数有：corePoolSize , maximumPoolSize , keepAliveTime ,workQueue,threadFactory,handler ,对于几个参数，我们该如何理解呢？
先看看这几个参数：
corePoolSize :
顾名思义，核心线程大小，即在没有任务需要执行的时候线程池的大小，并且只有在工作队列满了的情况下才会创建超出这个数量的线程；
maximuxPoolSize :
线程池中允许创建的最大线程数大小；
poolSize :
当前线程池中线程的数量，当改值为0的时候，意味着没有任何线程，线程池会终止；同时，poolSize不会超过maximumPoolSize;
看看官方解释：
Queuing
Any BlockingQueue may be used to transfer and hold submitted tasks. The use of this queue interacts with pool sizing:
● If fewer than corePoolSize threads are running, the Executor always prefers adding a new thread rather than queuing.
● If corePoolSize or more threads are running, the Executor always prefers queuing a request rather than adding a new thread.
● If a request cannot be queued, a new thread is created unless this would exceed maximumPoolSize, in which case, the task will be rejected.
理解：
1、如果当前线程池的线程数还没有达到核心线程数大小，即 poolSize < corePoolSize ,无论是否有空闲的线程，系统回新增一个线程来处理新提交的任务；
2、如果当前线程池的线程数大于或者等于核心线程数大小，即 poolSize >= corePoolSize,且任务队列未满时，将提交的任务提交到阻塞队列中，等待处理workQueue.offer(command);
3、如果当前线程池的线程数大于或者等于核心线程数大小，即 poolSize >= corePoolSize,且任务队列已满时，分以下两种情况：
3.1、poolSize < maximumPoolSize ，新增线程来处理任务；
3.2、poolSize = maximuxPoolSize ,意味中线程池的处理能力已经达到极限，此时会拒绝增加新的任务，至于如何拒绝，取决于RejectedExecutionHandler