探索Java 线程池

多线程可以说是开发应用程序的标配了，在Java中通常情况都是通过new Thread()来创建一个工作线程，如果需要并发执行任务时，以这种方式创建线程，由于线程的频繁创建和销毁，会消耗大量的系统资源，程序出现卡顿，甚至出现OOM。因此，Java中利用了线程池，它通过对已存在线程的重用，降低了线程创建和销毁所造成的资源消耗，可以自己控制并发数，不必等待新线程的创建时间便执行任务，提高了系统的响应速度。

Java通过Executors这个类，提供了四种线程池：

• newFixedThreadPool()
• newSingleThreadExecutor()
• newCachedThreadPool()
• newScheduledThreadPool()

下面分别会为这四种不同方式创建的线程池进行分析，在此之前，先看一段ThreadPoolExecutor的构造方法源码：

ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

ThreadPoolExecutor是Java线程池中的核心类，上面四种创建线程池的方式也是通过ThreadPoolExecutor类完成的，并且以静态工厂方法模式封装在了Executors这个类中。这个构造函数是包含参数最多的，都是ThreadPoolExecutor类的关键属性。看下面分析：

• corePoolSize：核心线程数，必须大于或等于0
• maximumPoolSize：线程池的最大线程数，必须大于1
• keepAliveTime：线程在空闲时候的存活时间，必须大于或等于0
• TimeUnit：存活的时间单位
• workQueue：线程池中的任务队列，不能为空
• threadFactory：线程工厂，不能为空
• handler：线程饱和策略，不能为空

注意：在创建线程池时，后面的条件限制必须满足，否则异常。对于参数少的构造方法，threadFactory和handler会使用默认。

对于这几个属性简单了解后，接着分析之前提到的四种线程池

1、newFixedThreadPool()

private void fixPool(){
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);   
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+" --- "+ finalI);
                }
            });
        }
    }

//...1   Executors类newFixedThreadPool()源码
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue());
    }

输出：

pool-1-thread-2 --- 1
pool-1-thread-1 --- 0
pool-1-thread-3 --- 2
pool-1-thread-1 --- 4
pool-1-thread-2 --- 3

在上面代码注释1处可以知道，用newFixedThreadPool()创建的线程池，其核心线程数和最大线程数是相同的，且无超时限制(线程空闲是不会被终止(回收))。采用了LinkedBlockingQueue阻塞队列。根据输出结果分析：当添加前三个任务时，若无空闲线程的情况下会创建一个新的线程去执行任务。当达到创建线程池时设定的核心线程数后，后续的任务会被放进阻塞队列LinkedBlockingQueue中，等待前面的线程执行完成后才进行提交。

2、newSingleThreadExecutor()

private void singlePool(){
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 3; i++) {
            final int finalI = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"  "+ finalI);
                }
            });
        }
    }

// Executors类newSingleThreadExecutor()源码
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue()));
    }

输出：

pool-1-thread-1  0
pool-1-thread-1  1
pool-1-thread-1  2
pool-1-thread-1  3
pool-1-thread-1  4

newSingleThreadExecutor()创建一个单线程的线程池，根据输出结果分析：串行的执行任务，若线程处于工作状态，任务会被放进阻塞队列LinkedBlockingQueue中，等待前面任务执行完成才会提交。

3、newCachedThreadPool()

private void cachePool(){
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            final int finalI = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+" --- "+ finalI);
                }
            });
        }
    }

// Executors类newCachedThreadPool()源码
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue());
    }

输出：

pool-1-thread-1 --- 0
pool-1-thread-3 --- 2
pool-1-thread-2 --- 1
pool-1-thread-5 --- 4
pool-1-thread-4 --- 3

newCachedThreadPool()创建的线程池，核心线程数是0；最大线程数是最大常数。设定了线程空闲时的存活时间为60s；SynchronousQueue队列不会存放任务，任务到来时就会被提交，执行。从输出结果可以发现：我们提交了5个任务，直接创建了5个线程进行执行。但是，在提交新任务时，如果有存在空闲的线程，则会重用这个空闲线程。我们改下上面代码，再看下输出结果。

private void cachePool(){
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            final int finalI = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+" --- "+ finalI);
                }
            });
           //每隔一秒提交一次
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

输出：

pool-1-thread-1 --- 0
pool-1-thread-2 --- 1
pool-1-thread-1 --- 2
pool-1-thread-2 --- 3
pool-1-thread-1 --- 4

4、newScheduledThreadPool()

 private void scheduledPool(){
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
        executorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("延时执行");
            }
        },2, TimeUnit.SECONDS);
    }

// Executors类newScheduledThreadPool()源码
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

//ScheduledExecutorService的构造方法
  public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    }

newScheduledThreadPool()创建的线程池，核心线程数自定义，最大线程数为最大常数。空闲时的存活时间默认DEFAULT_KEEPALIVE_MILLIS = 10ms，DelayedWorkQueue延时队列。上面的代码创建的是延时执行一次任务。还可利用scheduleAtFixedRate创建一个定时循环执行任务。

ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("定时循环执行");
            }
        },10,3000, TimeUnit.MILLISECONDS);

上面代码，创建了一个定时循环执行任务的线程池。初始执行延迟10ms，后续每一次任务相隔3000ms。
scheduleAtFixedRate和scheduleWithFixedDelay类似，其中的区别：scheduleAtFixedRate的相隔时间是上个线程执行开始到下个线程执行开始的时间。
scheduleWithFixedDelay的相隔时间是上个线程执行结束到下个线程执行开始的时间。

除了上面四种方式创建线程池，我们也可以通过ThreadPoolExecutor类自定义创建线程池，下面看一段AsyncTask中的源码(自定义线程池)

 private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE_SECONDS = 30;

 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        //允许核心线程超时终止
        threadPoolExecutor.allowCoreThreadTimeOut(true);

//sPoolWorkQueue
private static final BlockingQueue sPoolWorkQueue =
            new LinkedBlockingQueue(128);

//sThreadFactory
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };

线程池的关闭：

利用shutdown()或shutdownNow()关闭线程池

• shutdown()：把线程池的状态设置为SHUTDOWN状态，中断所有没有正在执行任务的线程池。
• shutdownNow()：把线程池的状态设置为STOP状态，中断所有的线程，包括正在执行任务的线程。

前面对线程池几个属性和创建方式进行了简单的阐述，下面再对几个属性进行详解：

• corePoolSize（核心线程数）：若线程池中的线程数小于corePoolSize，这时提交任务会创建新的线程执行。若大于或等于corePoolSize，提交任务时会根据是否存在空闲线程，决定是否创建新的线程来执行任务。也可以通过prestartCoreThread()或prestartAllCoreThreads()提前启动核心线程。

• maximumPoolSize（最大线程数）：线程池中允许的最大线程数量，如果线程池的队列已满，且线程数小于maximumPoolSize，会创建新的线程执行任务，否则会被拒绝（RejectedExecutionException）

• keepAliveTime（线程空闲存活时间）：这个超时限制是对超过corePoolSize的线程的控制，如果核心线程也要实现这个机制，可以利用allowCoreThreadTimeOut(true)进行设置

• TimeUnit（单位时间）：NANOSECONDS（纳秒），MICROSECONDS（微妙），MILLISECONDS（毫秒），SECONDS（秒），MINUTES（分），HOURS（小时），DAYS（天）；

• BlockingQueue（任务队列）：存放等待执行任务的阻塞队列。在线程数小于corePoolSize时，会创建新线程执行任务，不会进行排队。大于corePoolSize时，任务会添加到队列。若队列已满，且线程数不超过maximumPoolSize，则会创建新线程执行任务。否则会被拒绝。

• ThreadFactory（线程工厂）：用于创建新的线程，设置线程优先级。

• RejectedExecutionHandler（线程饱和策略）：
  ThreadPoolExecutor.AbortPolicy：处理程序遭到拒绝，则直接抛出运行时异常 RejectedExecutionException。(默认策略)
  ThreadPoolExecutor.CallerRunsPolicy：由调用线程执行该任务。策略实现了一种调节机制，不会抛弃任务，也不会抛出异常。
  ThreadPoolExecutor.DiscardPolicy：无法执行的任务将被删除。
  ThreadPoolExecutor.DiscardOldestPolicy：会先丢弃保存时间最长的任务(队列列头开始)，然后尝试添加新任务（失败后会重复前面的步骤）

常见的工作队列(BlockingQueue)：

• ArrayBlockingQueue ：基于数组的有界阻塞队列，当队列已满后添加会遭到拒绝。
• LinkedBlockingQueue：基于链表的阻塞队列（默认 Integer.MAX_VALUE），但可以通过构造函数去改变队列长度。
• SynchronousQueue：一种直接提交策略，特性：添加一次任务，必须等待线程取走这次任务后才能添加其它任务。
• PriorityBlockingQueue：优先级阻塞队列，插入元素时会按照定义的排序规则来对元素数组进行排序，入队的元素必须实现Comparable接口，执行时优先级高的会先被取出。