线程池,springboot工程中的异步

Posted 2021-09-16 fubin

Spring boot工程中的异步

SpringBoot 工程中默认支持异步操作，但是我们需要首先在启动类的上面，添加启动异步操作的注解(@EnableAsync)描述，代码如下：

@EnableAsync
@SpringBootApplication
public class DbpmsApplication {
 public static void main(String[] args) {
 SpringApplication.run(DbpmsApplication.class, args);
 }
 }

假如此时某个业务方法需要执行异步操作，可以使用@Async 注解对方法进行描述，例如写日志的业务，关键代码如下

@Async//次注解描述的方法为异步切入点方法
@Override
public void saveLog(SysLog sysLog) {
    try {
        Thread.sleep(10000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("findLogs.thread="+Thread.currentThread().getName());
    sysLogDao.insertLog(sysLog);
}

其中，@Async 注解描述的方法，在 spring 中会认为这是一个异步切入点方法， 在这个切入点方法执行时，底层会通过通知方法获取线程池中的线程，通过池中的线程调用切入点方法（底层默认池类ThreadPoolExecutor 类型）
简单使用ThreadPoolExecutor创建线程池

package com.cy;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;
public class ThreadPoolExecutorTests {
    //创建任务队列，存储执行的任务
 static BlockingQueue<Runnable> workQueue=
            new ArrayBlockingQueue<>(1);
    //构建线程工厂
 static ThreadFactory threadFactory=new ThreadFactory() {
        //线程前缀
 private String prefix="pool-thread-task-";
        //定义一个提供自增自减机制的对象
 private AtomicLong atomicLong=new AtomicLong(1);
        @Override
 public Thread newThread(Runnable r) {
            return new Thread(r, prefix+atomicLong.getAndIncrement());
        }
    };
    public static void main(String[] args) {
        //初始化一个线程池
 ThreadPoolExecutor tpool=
                new ThreadPoolExecutor(1,
                        2,
                        3,
                        TimeUnit.SECONDS,
                        workQueue,
                        threadFactory,
                        new ThreadPoolExecutor.AbortPolicy());
        tpool.execute(new Runnable() {
            @Override
 public void run() {
                String task=Thread.currentThread().getName()+"->task01";
                System.out.println(task);
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        tpool.execute(new Runnable() {
            @Override
 public void run() {
                String task=Thread.currentThread().getName()+"->task02";
                System.out.println(task);
                try{Thread.sleep(3000);}catch (Exception e){}
            }
        });
        tpool.execute(new Runnable() {
            @Override
 public void run() {
                String task=Thread.currentThread().getName()+"->task03";
                System.out.println(task);
                try{Thread.sleep(3000);}catch (Exception e){}
            }
        });
        tpool.execute(new Runnable() {
            @Override
 public void run() {
                String task=Thread.currentThread().getName()+"->task04";
                System.out.println(task);
                try{Thread.sleep(3000);}catch (Exception e){}
            }
        });
    }
}

结果：

pool-thread-task-1->task01
pool-thread-task-2->task03
pool-thread-task-1->task02//等待3秒出现

Java多线程：彻底搞懂线程池