一、Executors创建线程池
二、ThreadPoolExecutor类
三、ThreadPoolExecutor类扩展
一、Executors创建线程池
Java中创建线程池很简单，只需要调用Executors中相应的便捷方法即可，如Executors.newFixedThreadPool()、Executors.newSingleThreadExecutor()、Executors.newCachedThreadPool()等方法。这些方法虽然便捷，但是也有其局限性，如：OOM，线程耗尽。
小程序使用这些快捷方法没什么问题，对于服务端需要长期运行的程序，创建线程池应该直接使用ThreadPoolExecutor进行创建。上述便捷方法的创建也是通过ThreadPoolExecutor实现的。
二、ThreadPoolExecutor类
1、线程池工作顺序
线程池的工作顺序为：corePoolSize -> 任务队列 -> maximumPoolSize -> 拒绝策略
2、ThreadPoolExecutor构造函数
Executors中创建线程池的快捷方法，实际上是调用了ThreadPoolExecutor的构造方法，定时任务线程池便捷方法Executors.newScheduledThreadPool()内部使用的是ScheduledThreadPoolExecutor。ThreadPoolExecutor构造函数参数列表如下：
1 public ThreadPoolExecutor(int corePoolSize, //线程池核心线程数量
2 int maximumPoolSize, //线程池最大线程数量
3 long keepAliveTime, //超过corePooleSize的空闲线程的存活时长
4 TimeUnit unit, //空闲线程存活时长单位
5 BlockingQueue<Runnable> workQueue, //任务的排队队列
6 ThreadFactory threadFactory, //新线程的线程工厂
7 RejectedExecutionHandler handler) //拒绝策略
比较容易出问题的参数有corePoolSize、maximumPoolSize、workQueue以及handler：
- corePoolSize和maximumPoolSize设置不当会影响效率，甚至耗尽线程
- workQueue设置不当容易导致OOM
- handler设置不当会导致提交任务时抛出异常
3、workQueue任务队列
任务队列一般分为直接提交队列、有界任务队列、无解任务队列、优先任务队列。
- 直接任务队列：设置为SynchronousQueue队列。SynchronousQueue是一个特殊的BlockingQueue，它没有容量，每执行一个插入操作就会阻塞，需要再执行一个删除操作才会被唤醒；反之，每一个删除操作也要等待对应的插入操作。
1 public class SynchronousQueueTest { 2 3 private static ExecutorService pool; 4 5 public static void main(String[] args) { 6 7 //核心线程数设为1,最大线程数设为2,任务队列为SynchronousQueue,拒绝策略为AbortPolicy,直接抛出异常 8 pool = new ThreadPoolExecutor(1, 2, 0, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy()); 9 for(int i = 0;i < 3;i++){ 10 pool.execute(new ThreadTask()); 11 } 12 } 13 } 14 15 class ThreadTask implements Runnable{ 16 17 @Override 18 public void run() { 19 System.out.println(Thread.currentThread().getName()); 20 } 21 }
执行结果如下：
pool-1-thread-1
pool-1-thread-2
Exception in thread "main" java.util.concurrent.RejectedExecutionException:
Task com.aisino.threadPool.ThreadTask@2f0e140b rejected from java.util.concurrent.ThreadPoolExecutor@7440e464[Running,
pool size = 2, active threads = 0, queued tasks = 0, completed tasks = 2]
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 com.aisino.threadPool.SynchronousQueueTest.main(SynchronousQueueTest.java:18)
由执行结果可知，当任务队列为SynchronousQueue，创建的线程数大于maximumPoolSize时，直接执行拒绝策略抛出异常。
使用SynchronousQueue队列时，提交的任务不会被保存，总是会马上提交执行。如果用于执行任务的线程数小于maximumPoolSize，则尝试创建新的线程，如果达到maximumPoolSize设置的最大值，则根据设置的handler执行对应的拒绝策略。因此使用SynchronousQueue队列时，任务不会被缓存起来，而是马上执行，在这种情况下，需要对程序的并发量有个准确的评估，才能设置合适的maximumPoolSize数量，否则很容易执行拒绝策略。
- 有界任务队列：可使用ArrayBlockingQueue实现，如下所示：
pool = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),
Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
使用ArrayBlockingQueue有界任务队列时，如果有新的任务需要执行，线程池会创建新的线程，直到创建的线程数量达到corePoolSize,之后新的任务会被加入到等待队列中。若等待队列已满，即超过ArrayBlockingQueue初始化的容量，则继续创建线程，直到线程数量达到maximumPoolSize设置的最大线程数量，若大于maximumPoolSize,则执行拒绝策略。在这种情况下，线程数量的上限与有界任务队列的状态有直接关系，如果有界任务队列初始量较大或者没有达到超负荷的状态，线程数将一直维持在corePoolSize及以下；反之，当任务队列已满时，则会以maximumPoolSize为最大线程数上限。
- 无界的任务队列：可使用LinkedBlockingQueue实现，如下所示：
pool = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(),
Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
使用无界任务队列，线程池的任务队列可以无限制的添加新的任务，而线程池创建的最大线程数量就是corePoolSize。在这种情况下maximumPoolSize参数是无效的，哪怕任务队列中缓存了很多未执行的任务，当线程池的线程数达到corePoolSize后，线程数也不会再增加了。若后续有新的任务加入，则直接进入队列等待。使用这种任务队列模式时，要注意任务提交与处理之间的协调控制，不然会出现队列中的任务由于无法及时处理导致的一直增长，直到最后资源耗尽的问题。
- 优先任务队列：通过PriorityBlockingQueue实现，如下所示：
1 public class PriorityBlockingQueueTest { 2 3 private static ExecutorService pool; 4 public static void main(String[] args) { 5 6 //使用优先任务队列 7 pool = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, new PriorityBlockingQueue<Runnable>(), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy()); 8 for(int i = 0;i < 10;i++){ 9 pool.execute(new PriorityThreadTask(i)); 10 } 11 } 12 13 } 14 15 class PriorityThreadTask implements Runnable, Comparable<PriorityThreadTask>{ 16 17 private int priority; 18 19 public int getPriority(){ 20 return priority; 21 } 22 public void setPriority(int priority){ 23 this.priority = priority; 24 } 25 26 public PriorityThreadTask(){} 27 28 public PriorityThreadTask(int priority){ 29 this.priority = priority; 30 } 31 32 @Override 33 public void run() { 34 35 try{ 36 //让线程阻塞,使后续任务进入缓存队列 37 Thread.sleep(1000); 38 39 System.out.println("priority:" + this.priority + ", ThreadName:" + Thread.currentThread().getName()); 40 }catch(InterruptedException e){ 41 e.printStackTrace(); 42 } 43 } 44 45 //当前对象和其他对象作比较,当前优先级大就返回-1,当前优先级小就返回1,值越小优先级越高 46 @Override 47 public int compareTo(PriorityThreadTask o) { 48 return this.priority > o.priority ? -1 : 1; 49 } 50 }
执行结果如下：
priority:0, ThreadName:pool-1-thread-1
priority:19, ThreadName:pool-1-thread-1
priority:18, ThreadName:pool-1-thread-1
priority:17, ThreadName:pool-1-thread-1
priority:16, ThreadName:pool-1-thread-1
priority:15, ThreadName:pool-1-thread-1
priority:14, ThreadName:pool-1-thread-1
priority:13, ThreadName:pool-1-thread-1
priority:12, ThreadName:pool-1-thread-1
priority:11, ThreadName:pool-1-thread-1
priority:10, ThreadName:pool-1-thread-1
priority:9, ThreadName:pool-1-thread-1
priority:8, ThreadName:pool-1-thread-1
priority:7, ThreadName:pool-1-thread-1
priority:6, ThreadName:pool-1-thread-1
priority:5, ThreadName:pool-1-thread-1
priority:4, ThreadName:pool-1-thread-1
priority:3, ThreadName:pool-1-thread-1
priority:2, ThreadName:pool-1-thread-1
priority:1, ThreadName:pool-1-thread-1
由执行结果可看出，除了第一个任务直接创建线程执行外，其他的任务都被放入了优先任务队列PriorityBlockingQueue中，按优先级进行了重新排列执行，且线程池的线程数一直为corePoolSize,在本例中corePoolSize为1，即线程数一直为1。
PriorityBlockingQueue其实是一个特殊的无界队列，它其中无论添加了多少个任务，线程池创建的线程数量也不会超过corePoolSize。其他队列一般是按照先进先出的规则处理任务，而PriorityBlockingQueue队列可以自定义规则根据任务的优先级顺序先后执行。
4、handler拒绝策略
在创建线程池时，为防止资源被耗尽，任务队列都会选择创建有界任务队列。在创建有界任务队列模式下，当任务队列已满且线程池创建的线程数达到最大线程数时，需要指定ThreadPoolExecutor的RejectedExecutionHandler参数来处理线程池"超载"的情况。ThreadPoolExecutor自带的拒绝策略如下：
- AbortPolicy策略：该策略会直接会直接抛出异常，阻止系统正常工作
- DiscardPolicy策略：该策略会默默丢弃无法处理的任务，不予任何处理。使用此策略时，业务场景中需允许任务的丢失
- DiscardOldestPolicy策略：该策略会丢弃任务队列中最老的一个任务，即任务队列中最先被添加进去的、马上要被执行的任务，并尝试再次提交任务(重复此过程)
- CallerRunsPolicy策略：如果线程池的线程数量达到上限，该策略会把任务队列中的任务放在调用者线程当中运行
以上内置的拒绝策略均实现了RejectedExecutionHandler接口，也可自己扩展RejectedExecutionHandler接口，定义自己的拒绝策略。示例代码如下：
1 /** 2 * 自定义拒绝策略 3 */ 4 public class CustomRejectedExecutionHandlerTest { 5 6 private static ExecutorService pool; 7 8 public static void main(String[] args) { 9 10 //自定义拒绝策略 11 pool = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, 12 new ArrayBlockingQueue<>(5), 13 Executors.defaultThreadFactory(), 14 new RejectedExecutionHandler() { 15 @Override 16 public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { 17 System.out.println(r.toString() + " 执行了拒绝策略"); 18 } 19 }); 20 21 for (int i = 0; i < 10; i++) { 22 pool.execute(new CustomRejectedExecutionHandlerThreadTask()); 23 } 24 } 25 } 26 27 class CustomRejectedExecutionHandlerThreadTask implements Runnable { 28 29 @Override 30 public void run() { 31 try { 32 //让线程阻塞,使后续任务机进入缓存队列 33 Thread.sleep(1000); 34 System.out.println("线程名称:" + Thread.currentThread().getName()); 35 } catch (InterruptedException e) { 36 e.printStackTrace(); 37 } 38 } 39 }
执行结果如下：
com.aisino.threadPool.CustomRejectedExecutionHandlerThreadTask@3cd1a2f1 执行了拒绝策略
com.aisino.threadPool.CustomRejectedExecutionHandlerThreadTask@2f0e140b 执行了拒绝策略
com.aisino.threadPool.CustomRejectedExecutionHandlerThreadTask@7440e464 执行了拒绝策略
线程名称:pool-1-thread-2
线程名称:pool-1-thread-1
线程名称:pool-1-thread-2
线程名称:pool-1-thread-1
线程名称:pool-1-thread-2
线程名称:pool-1-thread-1
线程名称:pool-1-thread-2
由执行结果可看出，由于任务添加了休眠阻塞，执行任务需要花费一定时间，导致有一定数量的任务被丢弃，从而执行自定义的拒绝策略。
5、ThreadFactory自定义线程创建
线程池中的线程是通过ThreadPoolExecutor中的线程工厂ThreadFactory创建的。可自定义ThreadFactory对线程池中的线程进行一些特殊的设置(命名、设置优先级等)。示例代码如下：
1 public class CustomThreadFactoryTest { 2 3 private static ExecutorService pool; 4 5 public static void main(String[] args) { 6 //自定义线程工厂 7 pool = new ThreadPoolExecutor(2, 4, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(5), new ThreadFactory() { 8 @Override 9 public Thread newThread(Runnable r) { 10 System.out.println("创建线程:" + r.hashCode()); 11 //线程名称 12 Thread th = new Thread(r, "threadPool-" + r.hashCode()); 13 return th; 14 } 15 }, new ThreadPoolExecutor.CallerRunsPolicy()); 16 17 for(int i = 0;i < 10;i++){ 18 pool.execute(new CustomThreadFactoryThreadTask()); 19 } 20 } 21 } 22 23 class CustomThreadFactoryThreadTask implements Runnable{ 24 25 @Override 26 public void run(){ 27 //输出执行线程的名称 28 System.out.println("线程名称:" + Thread.currentThread().getName()); 29 } 30 }
执行结果如下：
创建线程:1259475182
创建线程:1300109446
创建线程:1020371697
线程名称:threadPool-1259475182
线程名称:threadPool-1300109446
线程名称:threadPool-1259475182
创建线程:789451787
线程名称:threadPool-1020371697
线程名称:threadPool-1259475182
线程名称:threadPool-1300109446
线程名称:threadPool-1259475182
线程名称:threadPool-1020371697
线程名称:threadPool-789451787
线程名称:threadPool-1300109446
由执行结果可看出，每个线程的创建都进行了记录输出与命名。
6、正确构造线程池
int poolSize = Runtime.getRuntime().availableProcessors() * 2;
BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(512);
RejectedExecutionHandler policy = new ThreadPoolExecutor.DiscardPolicy();
executorService = new ThreadPoolExecutor(poolSize, poolSize,
0, TimeUnit.SECONDS,
queue,
policy);
三、ThreadPoolExecutor类扩展
ThreadPoolExecutor类扩展主要是围绕beforeExecute()、afterExecute()和terminated()三个接口。
- beforeExecute:线程池中任务运行前执行
- afterExecute:线程池中任务运行完毕后执行
- terminated:线程池退出后执行
通过这三个接口可以监控每个任务的开始时间和结束时间，或者其他功能。示例代码如下：
1 public class ThreadPoolExecutorExtensionTest { 2 3 private static ExecutorService pool; 4 5 public static void main(String[] args) { 6 7 //自定义线程,为线程重命名 8 pool = new ThreadPoolExecutor(1, 4, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(5), new ThreadFactory() { 9 @Override 10 public Thread newThread(Runnable r) { 11 System.out.println("创建线程:" + r.hashCode()); 12 Thread th = new Thread(r, "ThreadPool-" + r.hashCode()); 13 return th; 14 } 15 }, new ThreadPoolExecutor.CallerRunsPolicy()){ 16 17 protected void beforeExecute(Thread t,Runnable r) { 18 System.out.println("准备执行的任务名称："+ ((ThreadPoolExecutorExtensionThreadTask)r).getTaskName()); 19 } 20 21 protected void afterExecute(Runnable r,Throwable t) { 22 System.out.println("执行完毕的任务名称："+((ThreadPoolExecutorExtensionThreadTask)r).getTaskName()); 23 } 24 25 protected void terminated() { 26 System.out.println("线程池退出"); 27 } 28 }; 29 30 for(int i = 0;i < 10;i++){ 31 pool.execute(new ThreadPoolExecutorExtensionThreadTask("Task-" + i)); 32 } 33 pool.shutdown(); 34 } 35 } 36 37 class ThreadPoolExecutorExtensionThreadTask implements Runnable{ 38 39 private String taskName; 40 41 public String getTaskName(){ 42 return taskName; 43 } 44 45 public void setTaskName(String taskName){ 46 this.taskName = taskName; 47 } 48 49 public ThreadPoolExecutorExtensionThreadTask(){} 50 51 public ThreadPoolExecutorExtensionThreadTask(String taskName){ 52 this.taskName = taskName; 53 } 54 55 @Override 56 public void run() { 57 //输出任务名称以及对应的执行线程名称 58 System.out.println("任务名称:" + this.taskName + ", 执行线程名称:" + Thread.currentThread().getName()); 59 } 60 }
执行结果如下：
创建线程:1259475182
创建线程:1300109446
创建线程:1020371697
准备执行的任务名称：Task-0
创建线程:789451787
任务名称:Task-0, 执行线程名称:ThreadPool-1259475182
准备执行的任务名称：Task-6
任务名称:Task-9, 执行线程名称:main
执行完毕的任务名称：Task-0
准备执行的任务名称：Task-7
准备执行的任务名称：Task-8
任务名称:Task-6, 执行线程名称:ThreadPool-1300109446
任务名称:Task-8, 执行线程名称:ThreadPool-789451787
执行完毕的任务名称：Task-8
准备执行的任务名称：Task-1
任务名称:Task-7, 执行线程名称:ThreadPool-1020371697
执行完毕的任务名称：Task-7
任务名称:Task-1, 执行线程名称:ThreadPool-1259475182
执行完毕的任务名称：Task-1
准备执行的任务名称：Task-2
任务名称:Task-2, 执行线程名称:ThreadPool-789451787
执行完毕的任务名称：Task-2
执行完毕的任务名称：Task-6
准备执行的任务名称：Task-5
任务名称:Task-5, 执行线程名称:ThreadPool-789451787
执行完毕的任务名称：Task-5
准备执行的任务名称：Task-4
准备执行的任务名称：Task-3
任务名称:Task-4, 执行线程名称:ThreadPool-1259475182
执行完毕的任务名称：Task-4
任务名称:Task-3, 执行线程名称:ThreadPool-1020371697
执行完毕的任务名称：Task-3
线程池退出
由执行结果可看出，通过对beforeExecute()、afterExecute()和terminated()的实现，可以对线程池中线程的状态进行监控，在线程执行前后输出了相关的打印信息。另外，使用shutdown()方法可以比较安全的关闭线程池，当线程池调用该方法后，线程池将不再接受后续添加的任务。但是，线程池不会立刻退出，而是等到添加到线程池中的任务都处理完成，才会退出。
扫一扫
1296
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
