多线程高并发编程学习笔记四

高并发编程学习笔记四：线程池
1.Executor：执行器，interface 用来执行某一个任务的，只有一个方法
    void execute(Runnable command)//运行一个实现了runnable的操作，可以交给一个线程使用
    e.g:
    public class MyExecutor implements Executor {
        @Override
        public void execute(Runnable command) {
            command.run();//直接运行该函数
            new Thread(command).start();//新建一个线程运行
        }
    }
2.ExecutorService：extends Executor 在后台运行的服务，可以往里面扔任务
    excute：执行器，运行runnable操作
    submit：用来执行callable操作
3.Callable：与runnable类似，都是被其他线程调用的，但是callable可以有返回值（泛型），runnable没有返回值。callable可以抛出异常，runnable不可以。
4.Executors:工具类，里面有很多静态方法，类似于Arrays，Collections
5.ThreadPool：线程池，一组线程用来执行高并发任务。线城市里面的线程并不会被销毁，一个线程执行完任务之后就会回到线程池，等待下一个任务。因为线程的开启和关闭很耗费资源，所以线程池更省资源。
    1.固定个数的线程池：线程池中的线程数目是固定的
    

public class MyThreadPool{
        public static void main(String[] args){
            ExecutorService executorService = Executors.newFixedThreadPool(5);
            for(int i = 0 ; i < 6 ; i++){
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }
        }
    }
    result：
            pool-1-thread-1
            pool-1-thread-4
            pool-1-thread-2
            pool-1-thread-3
            pool-1-thread-5
            pool-1-thread-1

    2.Cached缓存线程池/弹性的：每次新添加的任务都会检查线程池里面有没有空闲的线程，如果有，这个线程工作。如果没有新建一个线程。线程结束工作后会进入空闲状态等待任务（等待时间默认为60S，alivetime超过60S就销毁。60S内有任务就处理任务）
    

public class MyThreadPool{
        public static void main(String[] args){
            ExecutorService executorService = Executors.newCachedThreadPool();
            System.out.println(executorService);
            for(int i = 0 ; i < 6 ; i++){
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }
            System.out.println(executorService);
            try {
                TimeUnit.SECONDS.sleep(65);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(executorService);
        }
    }
    result：java.util.concurrent.ThreadPoolExecutor@7f31245a[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
            pool-1-thread-1
            pool-1-thread-3
            pool-1-thread-2
            pool-1-thread-5
            pool-1-thread-4
            pool-1-thread-6
            java.util.concurrent.ThreadPoolExecutor@7f31245a[Running, pool size = 6, active threads = 6, queued tasks = 0, completed tasks = 0]
            java.util.concurrent.ThreadPoolExecutor@7f31245a[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 6]
            60S后，所有的线程被关闭了

    3.单线程线程池：可以保证任务顺序执行，一定是第一个执行完了之后才执行第二个,newSingleThreadPool().
    4.计划线程池：scheduledThreadPool与delayQueue一样执行定时任务的，可以替代Timer。里面的线程是可以复用的。
    

public class MyScheduledThreadPool {
        public static void main(String[] args){
            ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);
            scheduledExecutorService.scheduleAtFixedRate(()->{
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            },0,500, TimeUnit.MILLISECONDS);
        }
    }
    result：pool-1-thread-1
            pool-1-thread-1
            pool-1-thread-2
            pool-1-thread-1
            pool-1-thread-3
            pool-1-thread-3
            pool-1-thread-4
    循环调用

    5.WorkThealing
    6.ForkJoinThreadPool //未完待续。。。。。