线程3 线程池

线程池，其实就是一个 容纳多个线程的容器 ，其中的线程可以反复使用，省去了频繁创建线程对象的操作 ，无需反复创建线程而消耗过多资源。

创建销毁线程是一个非常消耗性能的。

  

我们详细的解释一下为什么要使用线程池？

在java中，如果每个请求到达就创建一个新线程，开销是相当大的。在实际使用中， 创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。 如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。

使用线程池的好处：

降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

提高响应速度：当任务到达时，可以不需要等待线程创建就能立即执行。

提高线程的可管理性：线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，监控和调优。

数据库连接池（原理和线程池是一样的）：C3P0

传统JDBC的操作,每次创建和销毁连接都是非常消耗系统资源的两个过程，影响程序的运行效率！

连接管理：  为了解决性能问题，可以使用连接池优化的程序，来共享链接Connection

预先创建一组连接，放入到连接池中，用的时候每次取出一个； 用完后，放回；

---

Java里面线程池的顶级接口是 Executor，不过真正的线程池接口是 ExecutorService ， ExecutorService 的默认实现是 ThreadPoolExecutor；

普通类 Executors 里面调用的就是 ThreadPoolExecutor。

Executors：线程池创建工厂类

Executors 类提供工厂方法用来创建不同类型的线程池。比如: newSingleThreadExecutor() 创建一个只有一个线程的线程池，newFixedThreadPool(int numOfThreads)来创建固定线程数的线程池，newCachedThreadPool()可以根据需要创建新的线程，但如果已有线程是空闲的会重用已有线程。

看一下各个接口的源码：

Executors 提供四种线程池：

1）newCachedThreadPool 

是一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。调用 execute() 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。注意，可以使用 ThreadPoolExecutor 构造方法创建具有类似属性但细节不同（例如超时参数）的线程池。

2）newSingleThreadExecutor 

创建是一个单线程池，也就是该线程池只有一个线程在工作，所有的任务是串行执行的，如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它，此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

3）newFixedThreadPool 

创建固定大小的线程池，每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小，线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

 4）newScheduledThreadPool 

创建一个大小无限的线程池，此线程池支持定时以及周期性执行任务的需求。

通过 ThreadPoolExecutor 的构造函数，线程池相关参数的概念：

1）corePoolSize：3

线程池的核心线程数，一般情况下不管有没有任务都会一直在线程池中一直存活， 只有在 ThreadPoolExecutor 中的方法 allowCoreThreadTimeOut(boolean value) 设置为 true 时，闲置的核心线程会存在超时机制，如果在指定时间没有新任务来时，核心线程也会被终止，而这个时间间隔由第3个属性 keepAliveTime 指定。

2）maximumPoolSize：  7

线程池所能容纳的最大线程数，当活动的线程数达到这个值后，后续的新任务将会被阻塞。

3）keepAliveTime：4

控制线程闲置时的超时时长，超过则终止该线程 。 一般情况下用于 非核心线程 ， 只有在 ThreadPoolExecutor 中的方法 allowCoreThreadTimeOut(boolean value) 设置为 true时，也作用于核心线程。

4）unit：

用于指定 keepAliveTime 参数的时间单位，TimeUnit 是个 enum 枚举类型，常用的有：TimeUnit.HOURS(小时)、TimeUnit.MINUTES(分钟)、TimeUnit.SECONDS(秒) 和 TimeUnit.MILLISECONDS(毫秒)等。

5）workQueue：

线程池的任务队列，通过线程池的 execute(Runnable command) 方法会将任务 Runnable 存储在队列中。

6）threadFactory：

线程工厂，它是一个接口，用来为线程池创建新线程的。

线程池的关闭

ThreadPoolExecutor 提供了两个方法，用于线程池的关闭，分别是 shutdown() 和 shutdownNow()。

shutdown()：不会立即的终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务。

shutdownNow()：立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务。

面试题

1）什么是 Executor 框架？

Executor框架在Java 5中被引入，Executor 框架是一个根据一组执行策略调用、调度、执行和控制的异步任务的框架。

无限制的创建线程会引起应用程序内存溢出，所以创建一个线程池是个更好的的解决方案，因为可以限制线程的数量并且可以回收再利用这些线程。利用 Executor 框架可以非常方便的创建一个线程池。

2）Executors 类是什么？

Executors为Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类提供了一些工具方法。Executors 可以用于方便的创建线程池。

---

---

使用线程池的两种方式：Runnable接口Callable接口：

1）Callable 接口下的方法是 call()，Runnable 接口的方法是 run()。

2）Callable 的任务执行后可返回值，而 Runnable 的任务是不能返回值的。

3）call() 方法可以抛出异常，run()方法不可以的。

4）运行 Callable 任务可以拿到一个 Future 对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过 Future 对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

一、使用线程池方式--Runnable接口

通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。                                                                                                                                    

Executors：线程池创建工厂类

public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象

ExecutorService：线程池类

Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行

Future接口：用来记录线程任务执行完毕后产生的结果。

public class ThreadPoolRunnable implements Runnable {

    @Override

    public void run() {

     System. out.println(Thread. currentThread().getName() + "线程启动");

      try {

        Thread. sleep(1000);

     } catch (InterruptedException e) {

         e.printStackTrace();

     }

     System. out.println(Thread. currentThread().getName() + "线程使用完毕归还线程池.");

   }

}

线程执行完run方法，这个线程就执行完毕

public class ThreadPoolDemo {

    public static void main(String[] args) {

      //创建线程池对象,包含2个线程对象

     ExecutorService executorService = Executors. newFixedThreadPool(2);

     ThreadPoolRunnable runnable = new ThreadPoolRunnable();

      //不使用线程池启动线程的方式

      //Thread thread = new Thread(runnable);

      //thread.start();

      //从线程池中获取线程对象,然后调用MyRunnable中的run()

      executorService.submit( runnable);

      executorService.submit( runnable);

      executorService.submit( runnable);

      //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中

      //关闭线程池，一般不使用，因为我们使用线程池的目的就是为了复用线程。

      executorService.shutdown();

   }

}

pool-1-thread-1线程启动

pool-1-thread-2线程启动

pool-1-thread-2线程使用完毕归还线程池.

pool-1-thread-1线程使用完毕归还线程池.

pool-1-thread-1线程启动

pool-1-thread-1线程使用完毕归还线程池.

---

但是上面的方式有两个问题：

1、线程运行完之后是没有结果的，因为方法run的返回值是void。

2、run方法里面不能抛异常。

run方法已经定义好了，是不能修改的。

二、使用线程池方式—Callable接口

Callable接口：与Runnable接口功能相似，用来指定线程的任务。

                        其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。

ExecutorService：线程池类

                       <T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的call()方法

Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

public class ThreadPoolCallable implements Callable {

    @Override

    public Object call() throws Exception {

     System. out.println(Thread. currentThread().getName() + "线程启动");

     Thread. sleep(200);

     System. out.println(Thread. currentThread().getName() + "线程使用完毕归还线程池.");

      return Thread. currentThread().getName();

   }

}

public void test() throws InterruptedException, ExecutionException {

    // 创建线程池对象,包含2个线程对象

   ExecutorService executorService = Executors. newFixedThreadPool(2);

   ThreadPoolCallable callable = new ThreadPoolCallable();

    // 从线程池中获取线程对象

   Future<String> submit = executorService .submit( callable );

    String result = submit .get();

   System. out.println( "线程名字： " + result);

    // 关闭线程池，一般不使用，因为我们使用线程池的目的就是为了复用线程。

    executorService.shutdown();

}

---

使用线程池：返回两个数之间累加的结果

public class CalculateCallable implements Callable {

    private int begin = 0;

    private int end = 0;

    public CalculateCallable( int begin, int end) {

      this. begin = begin;

      this. end = end;

   }

    @Override

    public Object call() throws Exception {

      int result = 0;

      for ( int i = begin; i <= end; i++) {

         result += i;

     }

      return Thread. currentThread().getName() + " : " + result;

   }

}

public void test2() throws InterruptedException, ExecutionException {

   ExecutorService executorService = Executors. newFixedThreadPool(2);

    Future future1 = executorService .submit( new CalculateCallable(1, 100));

   System. out.println( future1.get());

    Future future2 = executorService .submit( new CalculateCallable(1, 10));

   System. out.println( future2.get());

    Future future3 = executorService .submit( new CalculateCallable(1, 20));

   System. out.println( future3.get());

}

pool-1-thread-1 : 5050

pool-1-thread-2 : 55

pool-1-thread-1 : 210

---