目录
1.基础知识
2.简单应用
3.异常机制
4.丰富的扩展
一.基础知识
构造函数。
public ThreadPoolExecutor(
int corePoolSize, 指的是保留的线程池大小
int maximumPoolSize, 指的是线程池的最大大小
long keepAliveTime, 指的是空闲线程结束的超时时间
TimeUnit unit,
BlockingQueue<Runnable> workQueue) 表示存放任务的队列
工作过程：
1 、线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。
2 、当调用 execute() 方法添加一个任务时，线程池会做如下判断：
a. 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；
b. 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列。
c. 如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要创建线程运行这个任务；
d. 如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常，告诉调用者“我不能再接受任务了”。
3 、当一个线程完成任务时，它会从队列中取下一个任务来执行。
4 、当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。
二.简单应用
public void threadPool1Test() throws InterruptedException {
BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();
ThreadPoolExecutor exe = new ThreadPoolExecutor(2, 6, 1, TimeUnit.DAYS, queue);
try {
int threadNum = 0;
for (int i = 0; i < 10; i++) {
threadNum++;
final int currentThreadNum = threadNum;
exe.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println("子线程[" + currentThreadNum + "]开启");
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println("子线程[" + currentThreadNum + "]结束");
}
}
});
}
//不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
System.out.println("已经开启所有的子线程");
exe.shutdown();
System.out.println("shutdown()：启动一次顺序关闭，执行以前提交的任务，但不接受新任务。");
//判断线程池所有任务是否执行完毕
while (true) {
if (exe.isTerminated()) {
System.out.println("所有的子线程都结束了！");
break;
}
Thread.sleep(1000);
System.out.println("线程池中线程数目："+exe.getPoolSize()+
"，队列中等待执行的任务数目："+ exe.getQueue().size()+
"，已执行玩别的任务数目："+exe.getCompletedTaskCount());
System.out.println("线程队列大小为-->"+queue.size());
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println("主线程结束");
}
}
1、BlockingQueue 只是一个接口，常用的实现类有 LinkedBlockingQueue 和 ArrayBlockingQueue。用 LinkedBlockingQueue 的好处在于没有大小限制。这样的话，因为队列不会满，所以 execute() 不会抛出异常，而线程池中运行的线程数也永远不会超过 corePoolSize 个，keepAliveTime 参数也就没有意义了。
2、shutdown() 方法不会阻塞。调用 shutdown() 方法之后，主线程就马上结束了，而线程池会继续运行直到所有任务执行完才会停止。如果不调用 shutdown() 方法，那么线程池会一直保持下去，以便随时添加新的任务。
二.异常处理
线程超出了线程池的总容量（线程队列大小+最大线程数）
@Test
public void threadPool2Test() throws InterruptedException {
ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 6, 1, TimeUnit.MILLISECONDS,
new ArrayBlockingQueue<Runnable>(4));
//executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
executor.setRejectedExecutionHandler(
new RejectedExecutionHandler() {
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println(String.format("Task %d rejected.", r.hashCode()));
//System.out.println("DemoTask Rejected : " + ((DemoThread) r).getName());
System.out.println("Waiting for a second !!");
try {
Thread.sleep(1000);
executor.execute(r);
//executor.getQueue().put(r);
} catch (InterruptedException e) {
}
}
});
///////
for (int i = 0; i < 11; i++) {
final int taskNum = i;
Runnable myTask = new Runnable() {
@Override
public void run() {
System.out.println("正在执行task " + taskNum);
try {
Thread.currentThread().sleep(100 * (new Random()).nextInt(8));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("task " + taskNum + "执行完毕");
}
};
executor.execute(myTask);
}
// 不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
executor.shutdown();
while (true) {
if (executor.isTerminated()) {
System.out.println("所有的子线程都结束了！");
break;
}
Thread.sleep(1000);
System.out.println("线程池中线程数目：" + executor.getPoolSize() + "，队列中等待执行的任务数目：" + executor.getQueue().size()
+ "，已执行玩别的任务数目：" + executor.getCompletedTaskCount());
}
}
ThreadPoolExecutor 提供 4 个现有的策略，分别是：
ThreadPoolExecutor.AbortPolicy：表示拒绝任务并抛出异常
ThreadPoolExecutor.DiscardPolicy：表示拒绝任务但不做任何动作
ThreadPoolExecutor.CallerRunsPolicy：表示拒绝任务，并在调用者的线程中直接执行该任务
ThreadPoolExecutor.DiscardOldestPolicy：表示先丢弃任务队列中的第一个任务，然后把这个任务加进队列。
使用CallerRunsPolicy，会将所有线程都执行到，也不可避免的会使用主线程来加载一个线程任务。一次同时创建maximumPoolSize个线程，加上主线程，就是一次执行maximumPoolSize+1个线程任务，等执行完后才会，再执行maximunPoolSize+1个线程任务，当然创建的maximumPoolSize个线程也会复用。
显然这种策略保证了每一个线程任务都会执行，但牺牲了性能。而，DiscardPolicy和DiscardOldestPolicy都会抛弃容纳不了的线程任务，保证了性能。
a. ThreadPoolExecutor可以设置一个“拒绝策略”，这是指当一个task被拒绝添加到线程池中时，采取的处理措施，
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
b.task非常重要，“等得起”，但是“丢不起”
System.out.println("Waiting for a second !!");
try {
Thread.sleep(1000);
executor.execute(r);
} catch (InterruptedException e) {
}
c.利用RejectedExecutionHandler来阻塞submit()？
首先 submit()方法是调用了workQueue的offer()方法来塞入task，而offer()方法是非阻塞的，当workQueue已经满的时候，offer()方法会立即返回false，并不会阻塞在那里等待workQueue有空出位置，所以要让submit()阻塞，关键在于改变向workQueue添加task的行为，
if (!executor.isShutdown()) {
try {
executor.getQueue().put(r);
} catch (InterruptedException e) {
}
}
调用了getQueue()方法，得到了workQueue，再调用其put()方法，将task放到workQueue中，而这个put()方法是阻塞的
当workQueue满时，submit()一个task会导致调用我们自定义的RejectedExecutionHandler，而我们自定义的RejectedExecutionHandler会保证该task继续被尝试 用阻塞式的put()到workQueue中。
d.重写了offer()方法的BlockingQueue
由于submit()是调用workQueue的offer()方法来添加task的，而offer()是非阻塞的，所以，如果我们自己实现一个BlockingQueue，其offer()方法是阻塞的
public class LimitedQueue<E> extends LinkedBlockingQueue<E> {
public LimitedQueue(int maxSize) {
super(maxSize);
}
@Override
public boolean offer(E e) {
// turn offer() and add() into a blocking calls (unless interrupted)
try {
put(e);
return true;
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
}
return false;
}
}
四.丰富的可扩展性
1.扩展生成器，如线程的创建前beforeExecute，创建后afterExecute，退出terminated；
线程的创建策略， 通过重构ThreadFactory 重构线程名，设置守护线程等；
线程的拒绝策略，日志，拒绝，重试等
线程运行抛出异常机制
class ExtThreadPoolExecutor extends ThreadPoolExecutor {
public ExtThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
super.setThreadFactory(new ExtThreadFactory());
super.setRejectedExecutionHandler(new ExtRejectedExecutionHandler());
}
@Override
protected void beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
System.out.println("Perform beforeExecute() ");
}
@Override
protected void terminated() {
System.out.println("线程池退出 ");
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
if (t != null) {
System.out.println("Perform exception handler logic");
}
System.out.println("Perform afterExecute() ");
}
/////////////////////////////////
// @Override
// public void execute(Runnable task) {
// super.execute(wrap(task,clientTrace(),Thread.currentThread().getName()));
// }
// @Override
// public Future<?> submit(Runnable task) {
// return super.submit(wrap(task,clientTrace(),Thread.currentThread().getName()));
// }
private Exception clientTrace(){
return new Exception("client stack trace");
}
private Runnable wrap(final Runnable task ,final Exception clientStack,String clientThreadName ){
return new Runnable(){
@Override
public void run() {
try {
task.run();
} catch (Exception e) {
clientStack.printStackTrace();
throw e;
}
task.run();
}
};
}
///////////////////////////////////////////
private class ExtThreadFactory implements ThreadFactory {
private AtomicInteger count = new AtomicInteger(0);
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
String threadName = ExtThreadPoolExecutor.class.getSimpleName() + count.addAndGet(1);
System.out.println("create "+threadName);
//t.setDaemon(true);
t.setName(threadName);
return t;
}
}
//
private class ExtRejectedExecutionHandler implements RejectedExecutionHandler {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println("DemoTask Rejected : " + ((DemoThread) r).getName());
System.out.println("Waiting for a second !!");
if (!executor.isShutdown()) {
try {
Thread.sleep(1000);
// executor.execute(r);
executor.getQueue().put(r);
// 当task被拒绝添加到线程池中时，ThreadPoolExecutor会采用“丢弃”策略来对待这个任务，即这个task被丢弃了。
// System.out.println("Lets add another time : " + ((DemoThread) r).getName());
} catch (InterruptedException e) {
}
}
}
}
}
2.扩展生成器
class DemoThread implements Runnable {
private String name = null;
public DemoThread(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
@Override
public void run() {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Executing : taskname: " + name +", Thread id: " +Thread.currentThread().getId());
}
}
public static void main(String[] args) {
BlockingQueue<Runnable> blockingQueue = new ArrayBlockingQueue<Runnable>(50);
ExtThreadPoolExecutor pool = new ExtThreadPoolExecutor(10, 20, 5000, TimeUnit.MILLISECONDS,
blockingQueue);
for (int i = 1; i < 100; i++) {
System.out.println("提交第" + i + "个任务!");
pool.execute(new DemoThread(Integer.valueOf(i).toString() ) );
pool.submit(new DemoThread(Integer.valueOf(i).toString() ));
}
// 2.销毁----此处不能销毁,因为任务没有提交执行完,如果销毁线程池,任务也就无法执行了
// exec.destory();
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}