线程池创建线程

定义：使用池化技术来管理和使用现成的技术，就叫做线程池
线程池的优势
总体来说，线程池有如下的优势：
（1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

1.创建固定个数的线程池

public class demo45 {
    public static void main(String[] args) {

        //创建固定个数的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        for(int i =0;i<2;i++){
            //执行任务
            service.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名:" +Thread.currentThread().getName());
                    //说明是使用线程池来创建线程
                }
            });
        }

    }
}

打印出来的线程名不是main，说明是通过线程池来创建线程

这里有一个经典问题
创建了10个线程来执行2个任务，问当前程序创建了几个线程？
答：启动了2个线程，打开jconsole观察

可以看到只有2个线程在执行

线程池的执行流程
当拿到一个任务之后，会判断当前线程池里面的线程数量是否达到了最大值，如果没有达到，创建新的线程执行任务；

当任务到来之后，当前线程池的线程数量已经是最大值，并且没有空闲的线程，当前的任务会被放到线程池的任务队列里面等待执行

public class demo45_2 {
    public static void main(String[] args) {

        // 创建固定个数的线程池
        ExecutorService service = Executors.newFixedThreadPool(1);
        // 定义任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("线程名：" +
                        Thread.currentThread().getName());
            }
        };
        // 执行任务
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
        service.execute(runnable);
    }
}

可以看到，在创建了1个线程之后，代码依然执行了10次，说明线程池里的任务队列起到了作用，完成了线程的10次启动.

设置线程的名称和优先级

通过线程工厂来实现（接口）

public class demo46 {
    public static void main(String[] args) {
        //线程工厂
        MyThreadFactory myThreadFactory = new MyThreadFactory();


        ExecutorService service = Executors.newFixedThreadPool(10,myThreadFactory);
        for(int i =0;i<10;i++){
            service.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名+" + Thread.currentThread().getName()+",
                    线程优先级"+Thread.currentThread().getPriority());
                }
            });
        }
    }

    private static int count = 1;

    static class MyThreadFactory implements ThreadFactory {
        @Override
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r);
            //设置线程池的命名
//            thread.setName("myThreadPool-" + count);
//            count++;
            thread.setName("myThreadPool-" + count++);

            //设置线程池的优先级
            thread.setPriority(10);
            return thread;
        }
    }
}

可以看到，已经可以自定义的设置线程名和线程优先级

2.创建带缓存的线程池

public class demo47 {
    public static void main(String[] args) {
        //创建带缓存的线程池

        ExecutorService service = Executors.newCachedThreadPool();

        //执行10个任务
        for (int i = 0; i <10 ; i++) {
            service.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名" + Thread.currentThread().getName());
                }
            });
        }
    }
}

适用场景，有大量的短期任务的时候.

3.创建可以执行定时任务的线程池

1.service.scheduleWithFixedDelay

public class demo48 {
    public static void main(String[] args) {

        //可以执行定时任务的线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(10);

        System.out.println("执行任务之前"+ new Date());
        //执行任务

        service.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务"+ new Date());
            }
        },1,3, TimeUnit.SECONDS);
    }
}

传递4个参数

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);

参数1 线程池的任务
参数2 定时任务延迟多长时间开始执行
参数3 定时任务的执行频率
参数4 配合参数2和参数3使用的时间单位

2.service.schedule

public class demo49 {
    public static void main(String[] args) {
        //可以执行定时任务的线程池   2
        ScheduledExecutorService service = Executors.newScheduledThreadPool(10);

        System.out.println("执行任务之前"+ new Date());
        //执行任务

        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务"+ new Date());
            }
        },3, TimeUnit.SECONDS);

    }
}

传递3个参数
参数1 线程池的任务
参数2 定时任务的执行频率
参数3 配合参数2使用的时间单位

schedule：
1.没有延迟执行的时间设置
2.定时任务只能执行一次

3.service.scheduleAtFixedRate

service.scheduleAtFixedRate：开始时间是以上次任务的结束时间作为起始时间，不会有延迟(固定的频率，不受其他方法干扰)

scheduleWithFixedDelay：任务开始时间是以上次任务执行的结束时间作为开始时间（时间不固定，根据任务执行的时长来订，可能会有sleep和wait方法进行干扰）

4.创建单个执行定时任务的线程池

public class demo51 {
    public static void main(String[] args) {

        //创建单个执行定时任务的线程池
        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();

        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("执行任务：" + new Date());
            }
        },1,3, TimeUnit.SECONDS);
    }
}

题目：单个线程的线程池有什么意义？
答：1.无需频繁的创建和销毁线程
2.可以更好的分配和管理以及存储任务（任务队列）

5.创建单个线程的线程池

public class demo52 {
    public static void main(String[] args) {
        //单个线程的线程池
        ExecutorService service = Executors.newSingleThreadExecutor();


        for (int i = 0; i < 10; i++) {
            service.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名：" +
                            Thread.currentThread().getName());
                }
            });
        }

    }
}

只打印一个线程名

6.(JDK 8+)根据当前的工作环境(CPU核心数、任务量) 异步线程池

执行即结束

同步执行流程：
1.main调用线程池
2.线程池执行完之后
3.关闭线程池，main也会随之关闭
异步执行流程：
1.main调用异步线程池
2.异步线程池后台执行，对于main线程来说异步线程池已经执行完成，关闭main线程

加上代码

//等待异步线程池执行完成（根据线程池的终止状态）
        while (!service.isTerminated()){
        }

判断线程是否终止，这时执行线程
当执行次数多时，会创建以当前CPU核数最大的线程数

7.常规设置线程池

设置虚拟机内存

最大运行内存10m
X ：执行的缩写
m：memory 内存
x： max最大值
10m ：单位

内存被设置为10m
执行任务超过规定的内存，会出现异常

Executors 创建线程池的问题：
1.线程数量不可控(线程的过度切换和争取-> 程序执行比较慢)
2.任务数量不可控(任务数无限大 Integer.MAX_VALUE),当任务量比较大的情况下就会造成内存溢出异常(OOM)