异步与线程池

解决问题：业务处理慢 比如：查询数据，处理请求

一、线程

1、初始化线程的4种方式

1）、继承Thread

 public static class Thread01 extends  Thread{
        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i=10/2;
            System.out.println("运行的结果"+i);
        }
    }

Thread01 thread01 = new Thread01();
       thread01.start();

2）、实现Runnable接口

 public  static class Thread02 implements Runnable{
        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i=10/2;
            System.out.println("运行的结果"+i);
        }
    }

 Thread02 thread02 = new Thread02();
        new Thread(thread02).start();

3）、实现Callable接口+FutureTask(可以拿到返回结果，可以处理异常) (阻塞等待)

 public static class Callable01 implements Callable<Integer>{
        @Override
        public Integer call() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i=10/2;
            System.out.println("运行的结果"+i);
            return i;
        }
    }

 FutureTask<Integer> futureTask = new FutureTask<>(new Callable01());
        new Thread(futureTask).start();
        //阻塞等待整个线程执行完成，获取返回结果
        Integer integer = futureTask.get();

4）、线程池

                给线程池直接提交任务

                1、创建

                        1）、Executors

                        2）、new ThreadPoolExecutor

                Future:可以获取到异步结果

                        

ExecutorService service = Executors.newFixedThreadPool(10);
   service.execute(new Runnable01());

* 7大参数
* int corePoolSize, 核心线程数一直存在除非（allowCoreThreadTimeOut）；线程池，创建好以后就准备就绪的线程数量，就等待来接受异步任务去执行
* int maximumPoolSize, 最大线程数量；控制资源
* long keepAliveTime,  存活时间。如果当前的线程数量大于core数量，释放空闲的线程。只要线程空闲大于指定的keepAliveTime
* TimeUnit unit, 时间单位
* BlockingQueue<Runnable> workQueue, 阻塞队列。如果任务很多，就会将目前多得任务放在队列里面。只要有线程空闲，就会去队列里面取出新的任务继续执行。
* ThreadFactory threadFactory, 线程的创建工厂
* RejectedExecutionHandler handler：如果队列蛮了，按照我们指定的拒绝策略拒绝执行任务

* 工作顺序：
*  1）、线程池创建，准备好core数量的核心线程，准备任务
*  1.1、core满了，就将再进来的任务收入阻塞队列中，空闲的core就会自己去阻塞队列获取任务执行
*  1.2、阻塞队列满了，就会直接开新线程执行，最大只能开到max指定的数量
*  1.3、max满了就用RejectedExecutionHandler拒绝任务
*  1.4、max都执行完成，有很多空闲，在指定的时间keepAliveTime ，释放max-core的线程
*
*          new linkedBlockingDeque<>();默认是Integer的最大值。内存不够。根据系统压力测试的到自己系统的最大值
*
*   一个线程池 core 7； max 20 ，queue：50，100 并发进来怎么分配的；
*   7个立即执行，50个进入等待，再开13个进行执行。剩余30个使用拒绝策略
*/

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5,
                200,
                10,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(100000),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

 常见的4中线程池

1.newCachedThreadPool   

核心数量是0，所有都可回收

2.newFixedThreadPool

固定大小，核心等于最大，都不可回收

3.newScheduledThreadPool

定时任务的线程池

4.newSingleThreadExecutor

单线程的线程池，后台从队列里面获取任务，挨个执行

业务代码里面，1，2，3不可取。原因：
如果100w个请求进来，没一个都new一个线程。那么系统直接资源耗尽，导致系统崩溃。

区别：

        1、2不能得到返回值。3可以获取返回值

        1、2、3都不能控制资源

        4可以控制资源，性能稳定 

5）、为什么使用线程池

1、降低资源消耗

2、提高响应速度

3、提高线程的可管理性