Java 并发编程＜13＞-ThreadPoolExecutor的springboot应用

Java 并发编程<13>-ThreadPoolExecutor的springboot应用

Java并发编程<10>安全集合

......

Java 并发编程<1>-线程实现的方式

线程池简介

a .为什么使用线程池

    降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗；

    提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行；

    方便线程并发数的管控，因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM，并且会造成cpu过度切换（cpu切换线程是有时间成本的（需要保持当前执行线程的现场，并恢复要执行线程的现场）

    提供更强大的功能，延时定时线程池

b.线程池为什么需要使用队列

    因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM，并且会造成cpu过度切换。

    创建线程池的消耗较高或者线程池创建线程需要获取mainlock这个全局锁，影响并发效率，阻塞队列可以很好的缓冲

c. 线程池为什么要使用阻塞队列

    阻塞队列可以保证任务队列中没有任务时阻塞获取任务的线程，使得线程进入wait状态，释放cpu资源，当队列中有任务时才唤醒对应线程从队列中取出消息进行执行。

    使得在线程不至于一直占用cpu资源。（线程执行完任务后通过循环再次从任务队列中取出任务进行执行，代码片段如：while (task != null || (task = getTask()) != null) {}）。

d.如何配置线程池

CPU密集型任务

    尽量使用较小的线程池，一般为CPU核心数+1。 因为CPU密集型任务使得CPU使用率很高，若开过多的线程数，会造成CPU过度切换

IO密集型任务

    可以使用稍大的线程池，一般为2*CPU核心数。IO密集型任务CPU使用率并不高，因此可以让CPU在等待IO的时候有其他线程去处理别的任务，充分利用CPU时间

混合型任务

     可以将任务分成IO密集型和CPU密集型任务，然后分别用不同的线程池去处理。 只要分完之后两个任务的执行时间相差不大，那么就会比串行执行来的高效因为如果划分之后两个任务执行时间有数据级的差距，那么拆分没有意义。

     因为先执行完的任务就要等后执行完的任务，最终的时间仍然取决于后执行完的任务，而且还要加上任务拆分与合并的开销，得不偿失。

execute和submit

execute()和submit()方法

1、execute()，执行一个任务，没有返回值。

2、submit()，提交一个线程任务，有返回值。

    submit(Callable<T> task)能获取到它的返回值，通过future.get()获取（阻塞直到任务执行完）。一般使用FutureTask+Callable配合使用

submit(Runnable task, T result)能通过传入的载体result间接获得线程的返回值。

    submit(Runnable task)则是没有返回值的，就算获取它的返回值也是null

Future.get()方法会使取结果的线程进入阻塞状态，直到线程执行完成之后，唤醒取结果的线程，然后返回结果。

springboot线程池示例一

    如果不自定义异步方法的线程池默认使用SimpleAsyncTaskExecutor。SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程。并发大的时候会产生严重的性能问题。

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

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

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

    SimpleThreadPoolTaskExecutor：是Quartz的SimpleThreadPool的类。线程池同时被quartz和非quartz使用，才需要使用此类

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

定义通用线程池，service直接使用

@Configurationpublic class ThreadPoolTaskConfig {    //cpu 核心数量    public static final int cpuNum = Runtime.getRuntime().availableProcessors();    /**     - 默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，     - 当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；     - 当队列满了，就继续创建线程，当线程数量大于等于maxPoolSize后，开始使用拒绝策略拒绝     */    /** 核心线程数（默认线程数） */    private static final int corePoolSize = cpuNum;    /** 最大线程数 */    private static final int maxPoolSize = cpuNum+1;    /** 允许线程空闲时间（单位：默认为秒） */    private static final int keepAliveTime = 60;    /** 缓冲队列大小 */    private static final int queueCapacity = 100;    @Bean    public ExecutorService getThreadPool(){        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(                corePoolSize,                maxPoolSize,                keepAliveTime,                TimeUnit.SECONDS,                new LinkedBlockingQueue(queueCapacity),                Executors.defaultThreadFactory());        return threadPoolExecutor;    }}

service中使用

@Slf4j@Servicepublic class AsyncService implements IAsyncService {   @Autowired   private ExecutorService threadPoolExecutor;   @Override   public void executeAsync() {        threadPoolExecutor.execute(()->{            log.info("threadPoolExecutorexecute");            try {                Thread.sleep(2000);            } catch (InterruptedException e) {                e.printStackTrace();            }        });    }}

controller

@RestControllerpublic class AsyncController {    @Autowired    private IAsyncService iAsyncService;    @GetMapping("/getAsync")    public void asyncMethod(){        iAsyncService.executeAsync();    }}执行结果如下：可以看到线程池起作用了2022-06-03 09:02:49.535 [http-nio-8081-exec-9] INFO  org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/] - Initializing Spring FrameworkServlet 'dispatcherServlet'2022-06-03 09:02:49.903 [pool-2-thread-1] INFO  com.converter.service.impl.AsyncService - threadPoolExecutor execute2022-06-03 09:02:51.825 [pool-2-thread-2] INFO  com.converter.service.impl.AsyncService - threadPoolExecutor execute2022-06-03 09:02:52.012 [pool-2-thread-3] INFO  com.converter.service.impl.AsyncService - threadPoolExecutor execute2022-06-03 09:02:52.216 [pool-2-thread-4] INFO  com.converter.service.impl.AsyncService - threadPoolExecutor execute2022-06-03 09:02:52.903 [pool-2-thread-1] INFO  com.converter.service.impl.AsyncService - threadPoolExecutor execute2022-06-03 09:02:54.826 [pool-2-thread-2] INFO  com.converter.service.impl.AsyncService - threadPoolExecutor

springboot线程池示例二

     Spring 通过任务执行器（TaskExecutor）来实现多线程和并发编程，使用ThreadPoolTaskExecutor实现一个基于线程池的TaskExecutor，

还得需要使用@EnableAsync开启异步，并通过在需要的异步方法那里使用注解@Async声明是一个异步任务

利用Spring注解使用线程池 

@EnableAsync@Configurationpublic class ThreadTestConfig {@Bean  //spring中@Async默认使用Bean Name为executor的线程池public Executor taskExecutor() {    ThreadPoolExecutor pool = new ThreadPoolExecutor(              corePoolSize,              maxPoolSize,              keepAliveTime,              TimeUnit.SECONDS,              new LinkedBlockingQueue(queueCapacity),              Executors.defaultThreadFactory());    return pool;}@Async默认使用Bean Name为executor的线程池。也可以根据Bean Name指定特定线程池@Async("taskExecuter")public void executeAsync() {    ......}

service

@Slf4j@Servicepublic class AsyncService implements IAsyncService {    @Autowired    private ExecutorService threadPoolExecutor;    @Override    @Async    public void executeAsync() {        log.info("executeAsync");        try {            Thread.sleep(2000);        } catch (InterruptedException e) {            e.printStackTrace();        }    }}

controller​​​​​

@RestControllerpublic class AsyncController {    @Autowired    private IAsyncService iAsyncService;    @GetMapping("/getAsync")    public void asyncMethod(){        iAsyncService.executeAsync();    }}

springboot线程池事务问题

    在@Async标注的方法，同时也使用@Transactional进行标注；在其调用数据库操作之时，将无法产生事务管理的控制，原因就在于其是基于异步处理的操作。

那该如何给这些操作添加事务管理呢？

可以将需要事务管理操作的方法放置到异步方法内部，在内部被调用的方法上添加@Transactional

    方法A， 使用了@Async/@Transactional来标注，但是无法产生事务控制的目的。

    方法B， 使用了@Async来标注，B中调用了C、D，C/D分别使用@Transactional做了标注，则可实现事务控制的目的。