JAVA中建立线程池的五种方法及比较

　　以前写过JAVA中建立线程的三种方法及比较。此次来讲说线程池。

　　JAVA中建立线程池主要有两类方法，一类是经过Executors工厂类提供的方法，该类提供了4种不一样的线程池可供使用。另外一类是经过ThreadPoolExecutor类进行自定义建立。

 

1、经过Executors类提供的方法。

一、newCachedThreadPool

建立一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收，若线程数不够，则新建线程。

代码例子：

 1     private static void createCachedThreadPool() {
 2         ExecutorService executorService = Executors.newCachedThreadPool();
 3         for (int i = 0; i < 10; i++) {
 4             final int index = i;
 5             executorService.execute(() -> {
 6                 // 获取线程名称,默认格式:pool-1-thread-1
 7                 System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
 8                 // 等待2秒
 9                 sleep(2000);
10             });
11         }
12     }

效果：

 

　　由于初始线程池没有线程，而线程不足会不断新建线程，因此线程名都是不同的。

 

二、newFixedThreadPool

建立一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待。

代码例子：

 1     private static void createFixedThreadPool() {
 2         ExecutorService executorService = Executors.newFixedThreadPool(3);
 3         for (int i = 0; i < 10; i++) {
 4             final int index = i;
 5             executorService.execute(() -> {
 6                 // 获取线程名称,默认格式:pool-1-thread-1
 7                 System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
 8                 // 等待2秒
 9                 sleep(2000);
10             });
11         }
12     }

效果：

 

　　由于线程池大小是固定的，这里设置的是3个线程，因此线程名只有3个。由于线程不足会进入队列等待线程空闲，因此日志间隔2秒输出。

 

三、newScheduledThreadPool

建立一个周期性的线程池，支持定时及周期性执行任务。

代码例子：

 1     private static void createScheduledThreadPool() {
 2         ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
 3         System.out.println(DateUtil.now() + " 提交任务");
 4         for (int i = 0; i < 10; i++) {
 5             final int index = i;
 6             executorService.schedule(() -> {
 7                 // 获取线程名称,默认格式:pool-1-thread-1
 8                 System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
 9                 // 等待2秒
10                 sleep(2000);
11             }, 3, TimeUnit.SECONDS);
12         }
13     }

效果：

 

　　由于设置了延迟3秒，因此提交后3秒才开始执行任务。由于这里设置核心线程数为3个，而线程不足会进入队列等待线程空闲，因此日志间隔2秒输出。

注意：这里用的是ScheduledExecutorService类的schedule()方法，不是ExecutorService类的execute()方法。

 

四、newSingleThreadExecutor

建立一个单线程的线程池，可保证全部任务按照指定顺序(FIFO, LIFO, 优先级)执行。

代码例子：

 1     private static void createSingleThreadPool() {
 2         ExecutorService executorService = Executors.newSingleThreadExecutor();
 3         for (int i = 0; i < 10; i++) {
 4             final int index = i;
 5             executorService.execute(() -> {
 6                 // 获取线程名称,默认格式:pool-1-thread-1
 7                 System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
 8                 // 等待2秒
 9                 sleep(2000);
10             });
11         }
12     }

效果：

 

　　由于只有一个线程，因此线程名均相同，且是每隔2秒按顺序输出的。

 

2、经过ThreadPoolExecutor类自定义。

　　ThreadPoolExecutor类提供了4种构造方法，可根据须要来自定义一个线程池。

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        // 省略...
    }

一、共7个参数以下：

（1）corePoolSize：核心线程数，线程池中始终存活的线程数。

（2）maximumPoolSize: 最大线程数，线程池中容许的最大线程数。

（3）keepAliveTime: 存活时间，线程没有任务执行时最多保持多久时间会终止。

（4）unit: 单位，参数keepAliveTime的时间单位，7种可选。

参数	描述
TimeUnit.DAYS	天
TimeUnit.HOURS	小时
TimeUnit.MINUTES	分
TimeUnit.SECONDS	秒
TimeUnit.MILLISECONDS	毫秒
TimeUnit.MICROSECONDS	微妙
TimeUnit.NANOSECONDS	纳秒

（5）workQueue: 一个阻塞队列，用来存储等待执行的任务，均为线程安全，7种可选。

参数	描述
ArrayBlockingQueue	一个由数组结构组成的有界阻塞队列。
LinkedBlockingQueue	一个由链表结构组成的有界阻塞队列。
SynchronousQueue	一个不存储元素的阻塞队列，即直接提交给线程不保持它们。
PriorityBlockingQueue	一个支持优先级排序的无界阻塞队列。
DelayQueue	一个使用优先级队列实现的无界阻塞队列，只有在延迟期满时才能从中提取元素。
LinkedTransferQueue	一个由链表结构组成的无界阻塞队列。与SynchronousQueue相似，还含有非阻塞方法。
LinkedBlockingDeque	一个由链表结构组成的双向阻塞队列。

较经常使用的是LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。

（6）threadFactory: 线程工厂，主要用来建立线程，默及正常优先级、非守护线程。

（7）handler：拒绝策略，拒绝处理任务时的策略，4种可选，默认为AbortPolicy。

参数	描述
AbortPolicy	拒绝并抛出异常。
CallerRunsPolicy	重试提交当前的任务，即再次调用运行该任务的execute()方法。
DiscardOldestPolicy	抛弃队列头部（最旧）的一个任务，并执行当前任务。
DiscardPolicy	抛弃当前任务。

 

二、顺便说下线程池的执行规则以下：

（1）当线程数小于核心线程数时，建立线程。

（2）当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。

（3）当线程数大于等于核心线程数，且任务队列已满：

若线程数小于最大线程数，建立线程。

若线程数等于最大线程数，抛出异常，拒绝任务。

 

代码例子：

 1     private static void createThreadPool() {
 2         ExecutorService executorService = new ThreadPoolExecutor(2, 10,
 3                 1, TimeUnit.MINUTES, new ArrayBlockingQueue<>(5, true),
 4                 Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
 5         for (int i = 0; i < 10; i++) {
 6             final int index = i;
 7             executorService.execute(() -> {
 8                 // 获取线程名称,默认格式:pool-1-thread-1
 9                 System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
10                 // 等待2秒
11                 sleep(2000);
12             });
13         }
14     }

效果：

 

　　由于核心线程数为2，队列大小为5，存活时间1分钟，因此流程是第0-1号任务来时，陆续建立2个线程，而后第2-6号任务来时，由于无线程可用，均进入了队列等待，第7-9号任务来时，没有空闲线程，队列也满了，因此陆续又建立了3个线程。因此你会发现7-9号任务反而是先执行的。又由于各任务只须要2秒，而线程存活时间有1分钟，因此线程进行了复用，因此总共只建立了5个线程。

 

3、五种方式的优劣比较

　　说是5种方式的比较，其实就是2种方式的比较，为何这么说？由于Executors类提供的4种方式，其底层其实都是经过ThreadPoolExecutor类来实现的。换句话说，就是Executors类工厂经过参数的组合，组装出了上面提到的4种类型线程池供不一样场景使用。咱们能够经过查看Executors类的源码来看看：

一、newCachedThreadPool

1     public static ExecutorService newCachedThreadPool() {
2         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
3                                       60L, TimeUnit.SECONDS,
4                                       new SynchronousQueue<Runnable>());
5     }

　　由于SynchronousQueue队列不保持它们，直接提交给线程，至关于队列大小为0，而最大线程数为Integer.MAX_VALUE，因此线程不足时，会一直建立新线程，等到线程空闲时，又有60秒存活时间，从而实现了一个可缓存的线程池。

 

二、newFixedThreadPool

1     public static ExecutorService newFixedThreadPool(int nThreads) {
2         return new ThreadPoolExecutor(nThreads, nThreads,
3                                       0L, TimeUnit.MILLISECONDS,
4                                       new LinkedBlockingQueue<Runnable>());
5     }

　　由于核心线程数与最大线程数相同，因此线程池的线程数是固定的，并且没有限制队列的大小，因此多余的任务均会被放到队列排队，从而实现一个固定大小，可控制并发数量的线程池。

 

三、newScheduledThreadPool

1     public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
2         return new ScheduledThreadPoolExecutor(corePoolSize);
3     }
4 
5     public ScheduledThreadPoolExecutor(int corePoolSize) {
6         super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
7               new DelayedWorkQueue());
8     }

　　由于使用了延迟队列，只有在延迟期满时才能从中提取到元素，从而实现定时执行的线程池。而周期性执行是配合上层封装的其余类来实现的，能够看ScheduledExecutorService类的scheduleAtFixedRate方法。

 

四、newSingleThreadExecutor

1     public static ExecutorService newSingleThreadExecutor() {
2         return new FinalizableDelegatedExecutorService
3             (new ThreadPoolExecutor(1, 1,
4                                     0L, TimeUnit.MILLISECONDS,
5                                     new LinkedBlockingQueue<Runnable>()));
6     }

　　由于核心线程数与最大线程数相同，均为1，因此线程池的线程数是固定的1个，并且没有限制队列的大小，因此多余的任务均会被放到队列排队，从而实现一个单线程按指定顺序执行的线程池。

 

　　虽然看上去Executors类的封装，能够简化咱们的使用，但事实上，阿里代码规范《阿里巴巴Java开发手册》中明确不建议使用Executors类提供的这4种方法：

【强制】线程池不容许使用Executors去建立，而是经过ThreadPoolExecutor的方式，这样的处理方式让写的同窗更加明确线程池的运行规则，规避资源耗尽的风险。

Executors返回的线程池对象的弊端以下:

FixedThreadPool和SingleThreadPool：容许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而致使OOM。

CachedThreadPool和ScheduledThreadPool：容许的建立线程数量为Integer.MAX_VALUE，可能会建立大量的线程，从而致使OOM。

　　再回头看看上面的源码，确实如此。因此咱们应该使用ThreadPoolExecutor类来建立线程池，根据本身须要的场景来建立一个合适的线程池。