Java多线程(四) 线程池

　　一个优秀的软件不会随意的创建、销毁线程，因为创建和销毁线程需要耗费大量的CPU时间以及需要和内存做出大量的交互。因此JDK5提出了使用线程池，让程序员把更多的精力放在业务逻辑上面，弱化对线程的开闭管理。

　　JDK提供了四种不同的线程池给程序员使用　　

　　首先使用线程池，需要用到ExecutorService接口，该接口有个抽象类AbstractExecutorService对其进行了实现，ThreadPoolExecutor进一步对抽象类进行了实现。最后JDK封装了一个Executor类对ThreadPoolExecutor进行实例化，因此通过Executor能够创建出具有如下四种特性的线程池

　　1. 无下界线程池

ExecutorService threadPool= Executors.newCachedThreadPool( ); 当线程数不足时，线程池会动态增加线程进行后续的任务调度

　　2. 固定线程数的线程池

ExecutorService threadPool= Executors.newFixedThreadPool(3); 创建具有固定线程数:3个的线程池

　　3. 单线程线程池

　　　ExecutorService threadPool= Executors.newSingleThreadScheduledExecutor( )；创建单例线程池，确保线程池内恒定有1条线程在工作

　　4. 调度线程池

　　   ScheduledExecutorService threadPool= Executors.newSingleThreadScheduledExecutor( ); 创建一个定长线程池，定时或周期性地执行任务

 package com.scl.thread.threadPool;

 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;

 public class ScheduledThreadPool
 {
     public static void main(String[] args)
     {
         // 创建定时调度线程池
         ScheduledExecutorService threadPool = Executors.newSingleThreadScheduledExecutor();
         // 定时执行Runnable
         threadPool.scheduleAtFixedRate(new Runnable()
         {

             @Override
             public void run()
             {
                 System.out.println("do some big Scheduled");
             }
         }, 10, 3, TimeUnit.SECONDS);
     }
 }

定时调度线程池

使用线程池也比较简单，只要往线程池里面提交"任务"即可，一般使用对象.submit的方法进行，如下：

　　　① threadPool.submit(Callable<T>task);

Callable跟Runnable接口一样在使用接口时会自动调用里面的call方法。与Runnable接口不一样的地方在于run方法不能返回内容，call方法含有返回参数,在外部可以通过Future 接口来接受线程返回的结果。如：Future<String> future = threadPool.submit(new MyTask( ));

② threadPool.submit(Runnable task);

由这个签名可以看出，同样地可以往线程池里面扔入Runnable接口实例。

　　这如上面所说，线程池的使用就是减少程序员对线程的启动和关闭。把线程的创建及关闭交给线程池来完成。因此使用线程池来完成线程的经典问题：生产者-消费者模型。

　　模型简介：该模型是一个典型的排队内容。模型分为三个主要角色：生产者、消费者、仓库。生产者和消费者共享仓库信息，①当仓库里面的产品满了，停止生产等待消费者去消费到足够的量再进行生产  ②当仓库里面的产品为空，等待生产者生产后再进行销售  ③仓库负责承载产品内容

　　根据模型内容，做成了一个车位管理的例子。分为三个角色：持车人（CarOwner）、保安（Secure）、车库（CarPark）。不同的持车人把车驶入到车库，保安负责记录车辆离开车库的数量。车库容量固定，如果车库为空保安可以通知持车人把车驶入车库。如果车库满了，保安告知持车人等待另外的持车人把车驾驶出来。车库使用一个列表对入库的车信息进行记录。

　　因此有如下类图：

　　

 package com.scl.thread.threadPool.CarParkManager;

 public class CarOwner implements Runnable
 {
     private int driverInNum;
     private CarPark carPark;

     public CarOwner(CarPark carPark)
     {
         this.carPark = carPark;
     }

     @Override
     public void run()
     {
         carPark.driverIn(driverInNum);
     }

     public int getDriverInNum()
     {
         return driverInNum;
     }

     public void setDriverInNum(int driverInNum)
     {
         this.driverInNum = driverInNum;
     }
 }

持车人 CarOwner

 package com.scl.thread.threadPool.CarParkManager;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;

 public class CarPark
 {
     protected int MaxCarNum;
     private List<Car> carList = new ArrayList<Car>();

     public CarPark(int maxNum)
     {
         this.MaxCarNum = maxNum;
     }

     public void driverIn(int num)
     {
         synchronized (carList)
         {
             while (num + carList.size() > MaxCarNum)
             {
                 System.out.println(Thread.currentThread() + ":无法进库，目前车库数目：" + carList.size());
                 try
                 {
                     carList.wait();
                 }
                 catch (InterruptedException e)
                 {
                     e.printStackTrace();
                 }
             }
             for (int i = 0; i < num; i++)
             {
                 try
                 {
                     Thread.sleep(20);
                 }
                 catch (InterruptedException e)
                 {
                     e.printStackTrace();
                 }
                 String uuid = UUID.randomUUID().toString();
                 Car c = new Car(uuid, uuid + i);
                 carList.add(c);
             }
             System.out.println(Thread.currentThread() + ":已经驶入" + num + "辆，目前车库数目：" + carList.size());
             carList.notify();
         }
     }

     public void driverOut(int num)
     {
         synchronized (carList)
         {

             while (carList.size() < num)
             {
                 System.out.println(Thread.currentThread() + ":无法驶出" + num + "辆，目前车库数目：" + carList.size());
                 try
                 {
                     carList.wait();
                 }
                 catch (InterruptedException e)
                 {
                     e.printStackTrace();
                 }
             }
             for (int i = num - 1; i >= 0; i--)
             {
                 try
                 {
                     Thread.sleep(20);
                 }
                 catch (InterruptedException e)
                 {
                     e.printStackTrace();
                 }
                 carList.remove(i);
             }
             System.out.println(Thread.currentThread() + ":已经驶出" + num + "辆，目前车库数目：" + carList.size());
             carList.notify();
         }
     }

     public List<Car> getCarList()
     {
         return carList;
     }

     public void setCarList(List<Car> carList)
     {
         this.carList = carList;
     }

 }

停车场 CarPark

 package com.scl.thread.threadPool.CarParkManager;

 public class Car
 {
     private String id;
     private String name;

     public Car(String id, String name)
     {
         this.id = id;
         this.name = name;
     }

 }

汽车信息类 Car

 package com.scl.thread.threadPool.CarParkManager;

 public class Secure implements Runnable
 {
     private int driverOutNum;

     private CarPark carPark;

     public Secure(CarPark carPark)
     {
         this.carPark = carPark;
     }

     public int getDriverOutNum()
     {
         return driverOutNum;
     }

     public void setDriverOutNum(int driverOutNum)
     {
         this.driverOutNum = driverOutNum;
     }

     @Override
     public void run()
     {
         carPark.driverOut(driverOutNum);
     }
 }

保安 Secute

 package com.scl.thread.threadPool.CarParkManager;

 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;

 public class Client
 {

     public static void main(String[] args)
     {
         // 设置车库最大值
         CarPark carPark = new CarPark(5);
         // 创建线程池
         ExecutorService threadPool = Executors.newCachedThreadPool();
         // 创建三个持车人
         CarOwner cw1 = new CarOwner(carPark);
         CarOwner cw2 = new CarOwner(carPark);
         CarOwner cw3 = new CarOwner(carPark);
         // 设置需要驶入的车辆数目
         cw1.setDriverInNum(3);
         cw2.setDriverInNum(3);
         cw3.setDriverInNum(1);

         // 创建三个保安
         Secure s1 = new Secure(carPark);
         Secure s2 = new Secure(carPark);
         Secure s3 = new Secure(carPark);
         s1.setDriverOutNum(1);
         s2.setDriverOutNum(2);
         s3.setDriverOutNum(1);

         threadPool.submit(cw1);
         threadPool.submit(cw2);
         threadPool.submit(cw3);
         threadPool.submit(s1);
         threadPool.submit(s2);
         threadPool.submit(s3);

     }

 }

客户端 Client

补充：很多时候我们都会写一些demo，然后用JUnit进行测试。多线程用JUnit来测试真的很好用，但是有个很不人性化的就是：线程池里面的任务都作为一个类似C#所说的工作者线程进行调用。即：当主线程运行完毕，线程池里面的东西还没执行完毕整个程序就退出了。让主线程去等待子线程执行，有几个方法：①用子线程调用join方法（线程池不适用，本来线程池就是要弱化对线程的操作）②在主线程内用Thread.sleep(10000); 然而我们没法知道线程池内的任务到底要多久，sleep的数值一直要设置很大 ③找个方法获取线程池是否把任务执行完毕。毫无疑问第三种方法是最佳的。

　　获取任务是否完成，需要按照以下两个步骤执行。（假如有线程池threadPool）

　　1. 停止往线程池提交任务。调用threadPool.shutdown( );

　　2. 循环判断线程池是否空置。调用threadPool.isTerminated( );

即可在Junit测试方法内，在添加完所有任务后，加上如下代码：

         threadPool.shutdown();
         while (true)
         {
             //如果任务已经执行完毕，则跳出循环
             if (threadPool.isTerminated())
             {
                 break;
             }
             //主线程等待
             Thread.sleep(1000);
         }
         //彻底关闭线程池
         threadPool.shutdownNow();

由上述代码可见，使用线程池和使用Thread类进行提交没有太大的差异。JDK5提供了一个阻塞队列的，能够更好地模拟生产者-消费者模型。后续再进行总结。

以上为线程池的总结内容，如有错漏烦请指出纠正。