线程池的实现

1.创建线程池

API提供了一个工具类叫Executors，可以用它的方法生成不同特点的线程池，返回一个ExecutorService对象。

<1>Executors.newCachedThreadPool() 【池子中默认是空的，最多可以容纳int类型的最大值】
<3>Executors.newSingleThreadExecutor() 【单个线程的线程池】

//都为工具类Executors的静态方法,返回一个ExecutorService对象
public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        //1.Executors.newCachedThreadPool()
        //创建一个默认的线程池对象，池子中默认是空的，最多可以容纳int类型的最大值
        ExecutorService executorService = Executors.newCachedThreadPool();
        //Executors---可以帮助我们创建线程池对象
        //ExecutorService---可以帮助我们控制线程池对象

        //3.单个线程的线程池
        //ExecutorService executorService2 = Executors.newSingleThreadExecutor();

        executorService.submit(() -> {
            System.out.println(Thread.currentThread().getName()+"在执行了");
        });
        executorService.submit(() -> {
            System.out.println(Thread.currentThread().getName()+"在执行了");
        });
        //由于第一个线程还没结束。第二个线程就开始，所以打印结果有两个线程

        System.out.println("--------------------------------------------");
        executorService.submit(() -> {
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });
        //让主线程睡眠1秒
        Thread.sleep(1000);
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "在执行了");
            }
        });
        //由于第一个线程已经归还完毕。第二个线程才开始，所以它会复用第线程池的线程，打印线程数不会增加
        executorService.shutdown();//关闭线程池
    }
}

打印结果：
-----------------------------------------------------------------------------------------
--------------------------------------------
pool-1-thread-3在执行了
pool-1-thread-1在执行了
pool-1-thread-2在执行了
pool-1-thread-1在执行了

<2>Executors.newFixedThreadPool()【参数不是初始值，而是最大值[提交数超过线程数，不会报错，而是复用线程]】 <4>Executors.newScheduledThreadPool(）【安排在给定周期执行某一个任务】

public class Demo2 {
    public static void main(String[] args) {
        //2.Executors.newFixedThreadPool()创建一个指定最多线程数量的线程池
        //参数不是初始值，而是最大值[提交数超过线程数，不会报错，而是复用线程]
        //ExecutorService executorService = Executors.newFixedThreadPool(2);
        ExecutorService executorService1 = Executors.newFixedThreadPool(2);
        executorService1.submit(() -> {
            System.out.println(Thread.currentThread().getName()+"在执行了");
        });
        executorService1.submit(() -> {
            System.out.println(Thread.currentThread().getName()+"在执行了");
        });
        executorService1.submit(() -> {
            System.out.println(Thread.currentThread().getName()+"在执行了");
        });//提交数为3，则会复用前面的线程

        //4.安排在给定周期执行某一个任务
        //Executors.newScheduledThreadPool(）
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行了");
            }
        }, 3, 5, TimeUnit.SECONDS);//初始延迟3秒，每5秒执行一次
    }
}

打印结果：
-----------------------------------------------------------------------------------------
pool-1-thread-1在执行了
pool-1-thread-2在执行了
pool-1-thread-1在执行了
pool-2-thread-1执行了
pool-2-thread-1执行了
pool-2-thread-2执行了

2.自定义线程池

//2.自定义线程池
//参数一:核心线程数量 【不能小于0】
//参数二:最大线程数  【不能小于等于0，最大数量》=核心线程数】
//参数三:空闲线程最大存活时间 【不能小于0】
//参数四:时间单位 【TimeUnit】
//参数五:任务队列【不能为null】 让任务在队列中等待，等线程空闲了，再从这个队列中获取任务并执行
//参数六:创建线程工厂【不能为null】 //创建和销毁的地方
//参数七:任务的拒绝策略【不能为null】  如果超过最大线程数的拒绝方案
public class Demo1 {
    public static void main(String[] args) {
        //创建线程池对象
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,//核心线程数量
                10,//最大线程数
                2,//空闲线程最大存活时间
                TimeUnit.HOURS,//时间单位
                new ArrayBlockingQueue<>(10),//任务队列
                Executors.defaultThreadFactory(),//创建线程工厂
                new ThreadPoolExecutor.AbortPolicy()//任务的拒绝策略[超出任务接收最大值则抛出异常]
        );
        //提交任务
        for (int i = 0; i < 3; i++) { //提交任务最大数为10+10【池中最大线程数+队列容量】
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"执行了");
                }
            });
        }
    }
}

打印结果：
---------------------------------------------------------------------------------------------------
pool-1-thread-2执行了
pool-1-thread-1执行了
pool-1-thread-2执行了