积累知识库：线程池的使用

1.基本使用

1.1 execute

    //新建线程池
	 private Executor esecutor = Executors.newFixedThreadPool(10);
	 //执行
	 esecutor.execute(new ExecuteTask(shoppId));
	 

      //创建YuanLingSliverTaskd对象实现Ruananle，在run方法里写代码
	  class YuanLingPushTask implements Runnable {
     
        String shoppId;
      

        public YuanLingPushTask(  String shoppId) {
            this.shoppId = shoppId;
        }

        @Override
        public void run() {
          //执行操作
        }

1.2 CountDownLatch线程计数器

CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。

  CountDownLatch latch = new CountDownLatch(page);
          for (int i = 0; i < page; i++) {
                int finalI = i;
                executorService.submit(new Runnable() {
                    @Override
                    public void run() {
                        Page<UserDO> userDOPage = new Page<>(finalI + 1, size);
                        Page<UserDO> userPage = easyExcelService.page(userDOPage);
                        pageMap.put(finalI,userPage);
                        countDownLatch.countDown();
                    }
                });
            }
            countDownLatch.await();
     执行......

1.3 如果想要有返回值的，配合callable

    
 public class Test {

    public static void main(String[] args) {

        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        Future<Integer> result = executor.submit(task);
        executor.shutdown();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
   
        System.out.println("主线程在执行任务");

        try {
            System.out.println("task运行结果"+result.get());
        } catch (InterruptedException e) {
          e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();

        }
        System.out.println("所有任务执行完毕");

    }

}

class Task implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        System.out.println("子线程在进行计算");
        Thread.sleep(3000);
        int sum = 0;
        for(int i=0;i<100;i++)
            sum += i;
        return sum;

    }
}

2.在springBoot中使用注解@Async完成异步

步骤：

1. 开启异步 ：在启动器或者新建配置类 @EnableAsync
2. 使用的话可以把异步的放在一个类中，加上直接@Component ， 在需要异步的方法上加上注解@Async
3. 在需要使用的类中注入这个异步类,调用方法

@Async自定义线程池

为什么？

使用@Async注解，在默认情况下用的是SimpleAsyncTaskExecutor线程池，该线程池不是真正意义上的线程池 。使用此线程池无法实现线程重用，每次调用都会新建一条线程。若系统中不断的创建线程，最终会导致系统占用内存过高，引发OutOfMemoryError错误。

Spring提供了多种线程池：

SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程。

SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只适用于不需要多线程的地方。

ConcurrentTaskExecutor：Executor的适配类，不推荐使用。如果ThreadPoolTaskExecutor不满足要求时，才用考虑使用这个类

ThreadPoolTaskScheduler：可以使用cron表达式

ThreadPoolTaskExecutor ：最常使用，推荐。其实质是对java.util.concurrent.ThreadPoolExecutor的包装

新建配置类（开启异步那个配置类）--配置线程池

@Configuration
@EnableAsync
public class SyncConfiguration {
    //此线程池的·名字----异步方法使用的时候可以指定
    @Bean(name = "asyncPoolTaskExecutor")
    public ThreadPoolTaskExecutor executor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        //核心线程数
        taskExecutor.setCorePoolSize(10);
        //线程池维护线程的最大数量,只有在缓冲队列满了之后才会申请超过核心线程数的线程
        taskExecutor.setMaxPoolSize(100);
        //缓存队列
        taskExecutor.setQueueCapacity(50);
        //许的空闲时间,当超过了核心线程出之外的线程在空闲时间到达之后会被销毁
        taskExecutor.setKeepAliveSeconds(200);
        //异步方法内部线程名称
        taskExecutor.setThreadNamePrefix("async-");
        /**
         * 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略
         * 通常有以下四种策略：
         * ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
         * ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
         * ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
         * ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，自动重复调用 execute() 方法，直到成功
         */
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        taskExecutor.initialize();
        return taskExecutor;
    }
}

---