【并发技术10】线程并发库的使用

1. 线程池的概念

在 java5 之后，就有了线程池的功能了，在介绍线程池之前，先来简单看一下线程池的概念。假设我开了家咨询公司，那么每天会有很多人过来咨询问题，如果我一个个接待的话，必然有很多人要排队，这样效率就很差，我想解决这个问题，现在我雇几个客服，来了一个咨询的，我就分配一个客服去接待他，再来一个，我再分配个客服去接待……如果第一个客服接待完了，我就让她接待下一个咨询者，这样我雇的这些客服可以循环利用。这些客服就好比不同的线程，那么装这些线程的容器就称为线程池。

2. Executors的使用

Executors 工具类是用来创建线程池的，这个线程池可以指定线程个数，也可以不指定，也可以指定定时器的线程池，它有如下常用的方法：

方法名	作用
newFixedThreadPool(int nThreads)	创建固定数量的线程池
newCachedThreadPool()	创建缓存的线程池
newSingleThreadExecutor()	创建单个线程
newScheduledThreadPool(int corePoolSize)	创建定时器线程池

2.1 固定数量的线程池

先来看下 Executors 工具类的使用：

1. public class ThreadPool {

2. //线程池的概念与Executors类的使用

3.    public static void main(String[] args) {

4.        //固定线程池：创建固定线程数去执行线程的任务，这里创建三个线程

5.        ExecutorService threadPool = Executors.newFixedThreadPool(3);

6.        for (int i = 1; i <= 10; i++) {//向池子里扔10个任务

7.            final int task = i;

8.            threadPool.execute(new Runnable() {//execute方法表示向池子中扔任务，任务即一个Runnable

9.                @Override

10.                public void run() {

11.                    for (int j = 1; j <= 5; j++) {

12.                        try {

13.                            Thread.sleep(20);

14.                        } catch (InterruptedException e) {

15.                            // TODO Auto-generated catch block

16.                            e.printStackTrace();

17.                        }

18.                        System.out.println(Thread.currentThread().getName()

19.                                + " looping of " + j + " for task of " + task);

20.                    }

21.                }

22.            });

23.        }

24.        System.out.println("all of 10 tasks have committed!");

25.        threadPool.shutdown(); //执行完任务后关闭

26. //        threadPool.shutdownNow(); //立即关闭

27.    }

28. }

从代码中可以看出，有了 Executors 工具类，我们创建固定数量的线程数就方便了，这些线程都去做同样的任务。 threadPool.execute 表示从池子里取出一个线程去执行任务，上面定义了三个线程，所以每次会取三个任务去让线程执行，其他任务等待，执行完后，再从池子里取三个任务执行，执行完，再取三个任务，最后一个任务三个线程有一个会抢到执行。所以定义了线程数量的话，每次会执行该数量的任务，因为一个线程一个任务，执行完再执行其他任务。

因为这个执行结果有点多，就不贴结果了，反正每次三个任务一执行，直到执行完10个任务为止。

2.2 缓存线程池

所谓缓存线程池，指的是线程数量不固定，一个任务来了，我开启一个线程为其服务，两个任务我就开启两个，N个任务我就开启N个线程为其服务。如果现在只剩1个任务了，那么一段时间后，就把多余的线程给干掉，保留一个线程为其服务。所以可以改写一下上面的代码：

1. public class ThreadPool {

2. //线程池的概念与Executors类的使用

3.    public static void main(String[] args) {

4.        //缓存的线程池

5.        //自动根据任务数量来设定线程数去服务，多了就增加线程数，少了就减少线程数

6.        //这貌似跟一般情况相同，因为一般也是一个线程执行一个任务，但是这里的好处是：如果有个线程死了，它又会产生一个新的来执行任务

7.        ExecutorService threadPool = Executors.newCachedThreadPool();

8.        for (int i = 1; i <= 10; i++) {//扔5个任务

9.            final int task = i;

10.            threadPool.execute(new Runnable() {//向池子中扔任务，任务即一个Runnable

11.                @Override

12.                public void run() {

13.                    for (int j = 1; j <= 5; j++) {

14.                        try {

15.                            Thread.sleep(20);

16.                        } catch (InterruptedException e) {

17.                            // TODO Auto-generated catch block

18.                            e.printStackTrace();

19.                        }

20.                        System.out.println(Thread.currentThread().getName()

21.                                + " looping of " + j + " for task of " + task);

22.                    }

23.                }

24.            });

25.        }

26.        System.out.println("all of 10 tasks have committed!");

27.        threadPool.shutdown(); //执行完任务后关闭

28.    }

29. }

使用缓存线程池的时候，会自动根据任务数量来产生线程数，即线程跟着任务走。运行结果也不贴了，有点多。

那么创建单个线程池 newSingleThreadExecutor() 就不写了，把上面那个方法改掉就行了，就只有一个线程去执行10个任务了，但是这跟我们平常直接 new 一个线程还有啥区别呢？它还有个好处就是，如果线程死了，它会自动再生一个，而我们自己 new 的就不会了。如果线程死了还要重新产生一个，也就是说要保证有一个线程在执行任务的话，那么 newSingleThreadExecutor() 是个很好的选择。

3. 线程池启动定时器

我们可以用静态方法 newScheduledThreadPool(intcorePoolSize) 来定义一个定时器线程池，可以指定线程个数。然后再调用 schedule 方法，传进去一个 Runnable 和定时时长即可，见代码：

1. public class ThreadPool {

2.    public static void main(String[] args) {

3.        Executors.newScheduledThreadPool(3).schedule(new Runnable() {          

4.            @Override

5.            public void run() {

6.                System.out.println(Thread.currentThread().getName() + " bombing");

7.            }

8.        }, 2, TimeUnit.SECONDS);        

9.    }

10. }

定义了三个线程，会有一个率先抢到任务执行在2秒后执行。这只是创建了一个任务，如果我们要使用这个线程池去执行多个任务咋办呢？schedule 中只能传入一个 Runnable，也就是说只能传入一个任务，解决办法跟上面那些程序一样，先拿到创建的线程池，再循环多次执行 schedule，每次都传进去一个任务即可：

1. public class ThreadPool {

2.    public static void main(String[] args) {

3.        //拿到定时器线程池

4.        ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);

5.        for(int i = 1; i <= 5; i ++) { //执行5次任务

6.            threadPool.schedule(new Runnable() {                

7.                @Override

8.                public void run() {

9.                    try {

10.                        Thread.sleep(1000);

11.                    } catch (InterruptedException e) {

12.                        // TODO Auto-generated catch block

13.                        e.printStackTrace();

14.                    }

15.                    System.out.println(Thread.currentThread().getName() + " bombing");

16.                }

17.            }, 2, TimeUnit.SECONDS);

18.        }  

19.    }

20. }

因为线程池中只有3个线程，但是有5个任务，所以会先执行3个任务，剩下两个任务，随机2个线程执行，看下结果：

pool-1-thread-3 bombing 

pool-1-thread-2 bombing 

pool-1-thread-1 bombing 

pool-1-thread-2 bombing 

pool-1-thread-3 bombing

如果我想5秒后执行一个任务，然后每个2秒执行一次该怎么办呢？我们可以调用另一个方法 scheduleAtFixedRate，这个方法中传进去一个 Runnable，一个定时时间和每次重复执行的时间间隔，如下：

1. public class ThreadPool {

2.    public static void main(String[] args) {

3.        Executors.newScheduledThreadPool(3).scheduleAtFixedRate(new Runnable() {            

4.            @Override

5.            public void run() {

6.                System.out.println(Thread.currentThread().getName() + " bombing");

7.            }

8.        }, 5, 2, TimeUnit.SECONDS);    

9.    }

10. }

这样就可以5秒后执行，并且以后每隔2秒执行一次了。这个方法有个瑕疵，就是无法设置指定时间点执行，官方JDK提供的解决办法是 data.getTime()-System.currentTimeMillis() 来获取相对时间，然后放到上面方法的第二个参数即可。

如果觉得对您有帮助，请转发给更多人吧~

关注“程序员私房菜”，学习更多技术干货，领取更多免费资源

↓↓↓