异步&线程池&异步编排

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

1、继承Thread
2、实现Runable接口
3、实现Callable接口+ FutureTask  可以拿到返回接口 可以处理异常
4、线程池

线程要执行 都需要通过new Thread().start() 执行
或者将线程交给线程池去执行
这样可以控制资源 性能稳定
//线程池 去执行线程
service.execute(new Runable01()); //提交给线程池 去执行

package com.atguigu.search.thread;

import java.util.concurrent.*;

/**线程测试类
 * */
public class ThreadTest {
    //创建线程池 确保系统中 止只有一到三个线程池  只要有异步任务 就提交给线程池 让它自己去执行
 public static   ExecutorService service = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main方法开始执行了");
        //启动thread01 线程
        Thread01 thread01 = new Thread01();
        thread01.start();

        //启动Thread01 线程
        Runable01 runable01 = new Runable01();
        new Thread(runable01).start();

        //启动Callable01 线程
        FutureTask futureTask = new FutureTask<>(new Callable01());
        new Thread(futureTask).start();
        Integer integer = futureTask.get();
        System.out.println("线程返回的结果是："+integer);

        System.out.println("main方法结束执行了");

        //线程池 去执行线程  
        service.execute(new Runable01()); //提交给线程池 去执行

    }

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

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

// 3、实现Callable接口
    public static class Callable01 implements Callable{

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

}

线程池

创建线程池

ThreadPoolExecutor excutor = new ThreadPoolExecutor();

线程池七大参数

1、核心线程数  corePoolSize  核心线程数一直存在 除非allowcareThreadTimeout 
2、最大线程数量 控制资源 maxmumPoolSize
3、存活时间 keepAliveTime 如果当前正在运行的线数量大于核心数量  运行线程 任务结束了 等待释放的时间
释放空闲的线程 只要线程  释放的是 超过核心线程的数量的线程   
4、unit 时间单位
5、BlockingQueue workQueie  阻塞队列  如果任务有很多 就会将多的任务放到队列里面 只要有
空闲的线程 就会去队列里面取出新的任务继续执行
6、threadFactory 线程的创建工厂  
7、handler 如果队列满了 按照我们指定的拒绝策略 拒绝执行任务 

手动创建线程池

 //手动创建线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                5,  //核心线程数
                20,  //最大线程数
                10, //最大存活时间
                TimeUnit.SECONDS, // 时间单位
                new LinkedBlockingDeque<>(100000), //阻塞队列 默认是Integer的最大长度 需要手动指定长度 防止资源耗尽
                new ThreadPoolExecutor.AbortPolicy()); // 拒绝策略    1、丢弃当前   2、丢弃最老的线程  默认是丢弃当前的线程任务
    

面试题

一个线程池 core:7 , max:20 ，queue: 50 ,100个并发进来 怎么分配的
答： 7个会立即得到执行 ，50个会进入等待队列 在开13个进行执行，剩下的30个就使用拒绝策略
丢弃策略 ，如果不想抛弃直接执行同步调用Run 或者丢弃最老的线程

Executors.newCachedThreadPool(); //core是0  所有都可以回收
Executors.newFixedThreadPool(10); //固定大小 core =最大
Executors.newScheduledThreadPool(10); //定时任务的线程池
Executors.newSingleThreadExecutor(); //单线程的线程池 后台从队列中获取任务 挨个执行

CompletableFuture 异步编排