Java中的四种线程池

线程池Executors

线程池概述

​  在进行多线程任务开发的时候，一个线程会经历如下四个阶段：

​  1. 创建线程

​  2. 创建任务

​   3. 执行任务

​  4. 关闭线程

​  如果一个线程的任务量很小，那么创建任务和执行任务将占整个流程的很少时间，多数时间用于创建线程和关闭线程，如果这样的任务有很多，还会导致系统频繁创建线程，浪费大量时间，降低效率。而线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省大量时间和资源。

​  线程池分为定长线程池和不定长线程池，以定长线程池为例，假设线程池能容纳四个线程，一开始有6个线程任务需要执行，这个时候线程池中的四个线程均处于空闲状态，如下图：

这个时候任务列表中会有四个任务会分配给四个空闲线程池，四个空闲线程池状态由空闲变为忙碌，另外两个线程池等待线程池中出现空闲线程：

​

如果这个时候再新增一个任务7，由于没有空闲线程，该任务会与任务5和6一起加入排队等待，等待线程池中出现空闲线程。假设此时任务4执行完毕了，那么任务列表中的一个任务会进入该线程，假设5进入：

任务列表中的其他任务会继续等待新的空闲线程出现。

线程池的好处

1. 降低资源消耗
2. 提高响应速度
3. 提高线程的可管理性

1. 缓存线程池

​ 缓存线程池长度无限制，任务加入后的执行流程为：

1. 判断线程池是否存在空闲线程
2. 存在则使用
3. 不存在，则创建线程，并放入线程池，然后使用

创建及使用方法如下：

        //1.创建线程池
        ExecutorService service = Executors.newCachedThreadPool();
        //2.向线程池中加入任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //主线程休眠一秒钟，确保上面三个任务执行完毕
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //再向线程池中加入线程
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

最终输出：

​ 从输出结果我们可以看到线程执行的先后顺序是不确定的，并且线程池1中的线程池1被使用了两次，这是因为当执行第4个任务时，最开始向线程添加的三个任务执行已经执行完毕，这个时候该任务就分配给了线程池1中的线程1。

2. 定长线程池

​ 定长线程池长度是指定的数值，任务加入后执行流程：

1. 判断线程池是否存在空闲线程
2. 存在则使用
3. 不存在空闲线程，且线程池未满的情况下，则创建线程，并放入线程池，然后使用
4. 不存在空闲线程，且线程池已经满了，则等待线程池中出现空闲线程

创建及使用方法如下：

public static void main(String[] args)  {
        //1.创建线程池
        ExecutorService service = Executors.newFixedThreadPool(2);
        //2.向线程池中加入任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

输出如下结果：

因为申请的线程池长度是2，所以第3和第4个任务会等待第1第2个任务执行完后出现空闲线程才能执行，线程1和线程2均被使用了两次。

3. 单线程线程池

​ 单线程线程池长度为1，任务加入后执行流程：

1. 判断线程池中的那个线程是否空闲
2. 空闲则使用
3. 不空闲则等待池中的那个线程空闲后使用

创建及使用方法如下：

public static void main(String[] args)  {
        //1.创建线程池
        ExecutorService service = Executors.newSingleThreadExecutor();
        //2.向线程池中加入任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

最终输出：

也就是说我们加入的所有任务都使用且只能使用线程1，因为线程池中只有一个线程

4. 周期定长线程池

​ 周期定长线程池也是定长线程池，但可以设置某个任务定时执行，当某个时机触发时，自动执行某任务。执行流程：

1. 判断线程池中是否存在空闲线程
2. 存在则使用
3. 不存在空闲线程，且线程池未满的情况下，则创建线程，并放入线程池，然后使用
4. 不存在空闲线程，且线程池已经满了，则等待线程池存在空闲线程。

创建及使用方法如下：

 public static void main(String[] args)  {
        //线程池长度设为2
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         * 第一种使用方法（一定时间后开始执行）
         * 参数1  定时执行的任务
         * 参数2  时长数字
         * 参数3  时长数字的时间单位，TimeUnit的常量指定
         */
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        },10, TimeUnit.SECONDS);//10秒后执行

        /**
         * 第二种使用方法（一定时间后开始周期执行，会一直周期执行下去）
         * 参数1  任务
         * 参数2  延迟时出数字（第一次执行在什么时间以后）
         * 参数3  周期时长数字（每隔多久执行一次）
         * 参数4  时长的数字单位
         */

        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        },5,1,TimeUnit.SECONDS);//5秒后执行，每隔1秒执行一次
    }

​ 这里需要注意的是第二种使用方法中，任务不是一直占用线程的，当一个周期任务执行完毕后，会归还线程，第二个周期的任务开始时，又会重新去分配新的线程。