常见的线程池简述

缓存线程池

缓存线程池（长度无限制）

任务加入后执行的流程

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

示例代码：

public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newCachedThreadPool();
        //指挥线程池执行新的任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行过了！！");
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行过了！！");
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行过了！！");
            }
        });

        Thread.sleep(1000);
        System.out.println("======休眠过后======");
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行过了！！");
            }
        });
    }
}

先定义了三个线程，然后执行休眠一秒的操作，如结果所示，在执行新的“任务”时其实还是调用了缓存的线程。
运行结果：

定长线程池

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

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

示例代码：

public class Demo4 {
    public static void main(String[] args) {
        //设置定长线程池长度为2
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行过了");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行过了");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行过了");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

此时执行结果：

此时第三次“任务”的执行是在6s之后的，满足不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程

单线程线程池

单线程线程池
执行流程：

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

public class Demo5 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行过了！");
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行过了！");
            }
        });

        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行过了！");
            }
        });
    }
}

执行结果：

无论执行多少次输出操作，都是用同一个线程。

周期定长线程池

周期定长线程池
执行流程：

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

周期性任务执行时：

定时执行，当某个时机触发时，自动执行某任务

示例代码:

public class Demo6 {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /*
        操作方法1：定时执行一次
        参数1，定时执行的任务
        参数2.时长数字
        参数3.时长数字的时间单位，TimeUnit的常量指定
         */
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("操作方法1执行过了!");
            }
        },5, TimeUnit.SECONDS);

        /*
        操作方法2：周期性执行任务
        参数1，任务
        参数2，延迟时长数字（第一次执行在多久之后）
        参数3. 周期时长数字（每隔多久执行一次任务）
        参数4. 时长数字的单位
         */
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("操作方法2执行过了！");
            }
        }, 2, 1, TimeUnit.SECONDS);
    }
}