线程池

一.线程池
    1.作用：创建有限的线程资源为更多的任务提供服务 （这也是一种模式--享元模式）
    2.java中对线程池的抽象：ExecutorService
    3.线程池既可以执行没有返回结果的任务，还可以执行带有返回结果的任务
    4.两个方法：
        submit()：用线程池的对象调用这个方法，然后用匿名内部类的方式把
    要执行的代码放写在里面。（实际调用的是Runnable接口里的run()方法）。
        shutdown():当所有的任务运行结束，关闭线程池，不在接受新的任务
二.ExecutorService的核心实现类：ThreadPoolExecutor
    ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue);
    1.int corePoolSize :线程池中日常保留的线程数目(核心线程数目)
    2.int maximumPoolSize : 线程池中最多的线程数目
    3.long keepAliveTime :救急线程在不接受任务的时候，他的最大生存时间
    4.TimeUnit unit：表示时间的单位
    5.BlockingQueue<Runnable> workQueue ：阻塞队列，如果任务数目超过
了核心线程数目，超过的任务就会在阻塞队列里面排队，直到有空闲的线程。可以设置
长度。
    6.如果任务过多，核心线程数目和阻塞队列都被占完，则会启动救急线程。
            注意：救急线程+核心线程数目<=线程中最多的线程数目
    代码展示：
    public class Demo4  {

        public static void main(String[] args) {

           ExecutorService service =
                new ThreadPoolExecutor(3,6,60, TimeUnit.SECONDS,new ArrayBlockingQueue<>(10));
        for (int i=0;i<20;i++) {
            service.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "好久不见");
            });
        }

    }
}

三.线程池的创建
    1.创建固定大小的线程池
        Executors.newFixedThreadPool(你所需要的线程数目);
        特点：a.核心线程数=最大线程数(没有救急线程被创建)
             b.阻塞队列，无界，可以放任意数量的任务
             c.适合执行数量有限，长时间运行的任务
        代码展示：
        public class Demo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程池
        ExecutorService ets = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            ets.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "你好");
            });
     } //无返回值
       Future future = ets.submit(() -> {
            System.out.println(Thread.currentThread().getName() + "大哥");
            return "神马东西";
        });
        System.out.println(future.get()); //获取返回值
        ets.shutdown();
    }//有返回值的
}
    2.创建缓冲线程池
        Executors.newCachedThreadPool() 
        特点： a.核心线程数是0
              b.最大线程数是integer的最大值（也就意味着，救急线程数
        可以被无限的创建） 
              c.救急线程在不执行任务的情况下，最大的生存时间是60秒
              d.适合任务比较密集，但每个任务执行的时间较短的情况
        代码展示：
        public class Demo5 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService ets = Executors.newCachedThreadPool();
        for (int i=0;i<10;i++) {
            Future f = ets.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "你好");
                return "大金刚";
            });
            System.out.println(f.get());
        }
    }
}
    3.创建单线程线程池
        Executors.newSingleThreadExecutor() 
        使用场景：希望多个任务排队执行
        代码展示：
        public class Demo {
    public static void main(String[] args) {
        //创建单线程线程池
        ExecutorService ets = Executors.newSingleThreadExecutor();
        ets.submit(()->{
            System.out.println("你好");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        ets.submit(()->{
            System.out.println("我很好");
        }
    }
}
    4.创建带有日程安排功能的线程池
             ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
          代码展示：
          public class Demo1 {
    public static void main(String[] args) {
        //带有日程安排的线程池
        ScheduledExecutorService ses = Executors.newScheduledThreadPool(5);

        ses.schedule(() -> {                  //让任务推迟一段时间后在执行  任务对象1，推迟时间2，3
            System.out.println("大王来巡山啊！！！");
        }, 10L, TimeUnit.SECONDS);
        // 以一定的频率反复执行任务（任务不会重叠）
        ses.scheduleAtFixedRate(() -> {
            System.out.println("你好，兄弟");
        }, 2, 1, TimeUnit.SECONDS);//任务推迟2秒开始，并且之后每隔一秒执行一次
        ses.scheduleWithFixedDelay(()->{
            System.out.println("你好吗");
        },2,1,TimeUnit.SECONDS);//任务推迟两秒开始，并且每两个任务之间的间隔时间为1秒
    }
}