1、任务数<=核心线程数时，核心线程去处理任务。
此例中任务数2，核心线程数2
package multhread;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorAbout {
public static void main(String[] args) {
LinkedBlockingQueue queue = new LinkedBlockingQueue<>(3);
ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 6, 2, TimeUnit.MINUTES, queue);
// 此处i用来模拟任务数，但不准确（因为或许下个循环还没开始，上个循环就已经结束进入空闲状态，所以i=300不代表就有300个并发任务），
// 不过在线程中线程睡眠了5s，差不多能满足所有的循环执行完同时线程还没结束。大概明白这个意思就好了
for (int i = 0; i < 2; i++) {
RunThread runThread = new RunThread(i,queue);
pool.execute(runThread);
}
}
static class RunThread implements Runnable {
private int count;
private LinkedBlockingQueue queue;
public RunThread(int count, LinkedBlockingQueue queue) {
this.count = count;
this.queue = queue;
}
@Override
public void run() {
System.out.println("第" + count + "次进入线程,线程名：" + Thread.currentThread().getName() +
"此时阻塞队列size:" + queue.size());
try {
Thread.sleep(5*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
结果：
第0次进入线程,线程名：pool-1-thread-1此时阻塞队列size:0
第1次进入线程,线程名：pool-1-thread-2此时阻塞队列size:0
2、核心线程数<任务数<=(核心线程数+队列容量)时,
此例中，n=5时，2个核心线程去处理其中的2个任务，其余3个放入阻塞队列queue中，等待核心线程空闲下来再执行。
package multhread;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorAbout {
public static void main(String[] args) {
LinkedBlockingQueue queue = new LinkedBlockingQueue<>(3);
ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 6, 2, TimeUnit.MINUTES, queue);
// 此处i用来模拟任务数，但不准确（因为或许下个循环还没开始，上个循环就已经结束进入空闲状态，所以i=300不代表就有300个并发任务），
// 不过在线程中线程睡眠了5s，差不多能满足所有的循环执行完同时线程还没结束。大概明白这个意思就好了
for (int i = 0; i < 5; i++) {
RunThread runThread = new RunThread(i,queue);
pool.execute(runThread);
}
}
static class RunThread implements Runnable {
private int count;
private LinkedBlockingQueue queue;
public RunThread(int count, LinkedBlockingQueue queue) {
this.count = count;
this.queue = queue;
}
@Override
public void run() {
System.out.println("第" + count + "次进入线程,线程名：" + Thread.currentThread().getName() +
"此时阻塞队列size:" + queue.size());
try {
Thread.sleep(5*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
结果：
第1次进入线程,线程名：pool-1-thread-2此时阻塞队列size:3
第0次进入线程,线程名：pool-1-thread-1此时阻塞队列size:3
第2次进入线程,线程名：pool-1-thread-2此时阻塞队列size:2
第3次进入线程,线程名：pool-1-thread-1此时阻塞队列size:1
第4次进入线程,线程名：pool-1-thread-1此时阻塞队列size:0
3、(核心线程数+队列容量)<任务数<=(最大线程数+队列容量)时，
此例中，任务数n=8时，2个核心线程去处理其中的2个任务，其余6个中3个放入阻塞队列queue中，还剩余3个直接被线程池中非核心线程（线程池中最大线程数为6）直接执行。
package multhread;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorAbout {
public static void main(String[] args) {
LinkedBlockingQueue queue = new LinkedBlockingQueue<>(3);
ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 6, 2, TimeUnit.MINUTES, queue);
// 此处i用来模拟任务数，但不准确（因为或许下个循环还没开始，上个循环就已经结束进入空闲状态，所以i=300不代表就有300个并发任务），
// 不过在线程中线程睡眠了5s，差不多能满足所有的循环执行完同时线程还没结束。大概明白这个意思就好了
for (int i = 0; i < 8; i++) {
RunThread runThread = new RunThread(i,queue);
pool.execute(runThread);
}
}
static class RunThread implements Runnable {
private int count;
private LinkedBlockingQueue queue;
public RunThread(int count, LinkedBlockingQueue queue) {
this.count = count;
this.queue = queue;
}
@Override
public void run() {
System.out.println("第" + count + "次进入线程,线程名：" + Thread.currentThread().getName() +
"此时阻塞队列size:" + queue.size());
try {
Thread.sleep(5*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
结果：
第1次进入线程,线程名：pool-1-thread-2此时阻塞队列size:3
第5次进入线程,线程名：pool-1-thread-3此时阻塞队列size:3
第0次进入线程,线程名：pool-1-thread-1此时阻塞队列size:3
第6次进入线程,线程名：pool-1-thread-4此时阻塞队列size:3
第7次进入线程,线程名：pool-1-thread-5此时阻塞队列size:3
第4次进入线程,线程名：pool-1-thread-1此时阻塞队列size:0
第3次进入线程,线程名：pool-1-thread-3此时阻塞队列size:0
第2次进入线程,线程名：pool-1-thread-2此时阻塞队列size:0
4、任务数>(最大线程数+队列容量)时，
此例中，任务数n=10时，2个核心线程去处理其中的2个任务，队列queue放入3个，非核心线程处理4个，还剩下一个任务，此时处理完9个任务并报java.util.concurrent.RejectedExecutionException异常
package multhread;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorAbout {
public static void main(String[] args) {
LinkedBlockingQueue queue = new LinkedBlockingQueue<>(3);
ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 6, 2, TimeUnit.MINUTES, queue);
// 此处i用来模拟任务数，但不准确（因为或许下个循环还没开始，上个循环就已经结束进入空闲状态，所以i=300不代表就有300个并发任务），
// 不过在线程中线程睡眠了5s，差不多能满足所有的循环执行完同时线程还没结束。大概明白这个意思就好了
for (int i = 0; i < 10; i++) {
RunThread runThread = new RunThread(i,queue);
pool.execute(runThread);
}
}
static class RunThread implements Runnable {
private int count;
private LinkedBlockingQueue queue;
public RunThread(int count, LinkedBlockingQueue queue) {
this.count = count;
this.queue = queue;
}
@Override
public void run() {
System.out.println("第" + count + "次进入线程,线程名：" + Thread.currentThread().getName() +
"此时阻塞队列size:" + queue.size());
try {
Thread.sleep(5*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
结果：
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task multhread.ThreadPoolExecutorAbout$RunThread@4b67cf4d rejected from java.util.concurrent.ThreadPoolExecutor@7ea987ac[Running, pool size = 6, active threads = 6, queued tasks = 3, completed tasks = 0]
at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
at multhread.ThreadPoolExecutorAbout.main(ThreadPoolExecutorAbout.java:22)
第0次进入线程,线程名：pool-1-thread-1此时阻塞队列size:3
第1次进入线程,线程名：pool-1-thread-2此时阻塞队列size:3
第5次进入线程,线程名：pool-1-thread-3此时阻塞队列size:3
第6次进入线程,线程名：pool-1-thread-4此时阻塞队列size:3
第7次进入线程,线程名：pool-1-thread-5此时阻塞队列size:3
第8次进入线程,线程名：pool-1-thread-6此时阻塞队列size:3
第2次进入线程,线程名：pool-1-thread-2此时阻塞队列size:1
第4次进入线程,线程名：pool-1-thread-3此时阻塞队列size:0
第3次进入线程,线程名：pool-1-thread-1此时阻塞队列size:1
