java实现异步任务功能的方法

星空下夜猫子

已于 2023-07-20 08:57:59 修改

阅读量2.6k

点赞数

文章标签： java 开发语言

于 2023-07-20 08:57:16 首次发布

本文链接：https://blog.csdn.net/weixin_49999835/article/details/131768387

版权

异步简介

异步编程是一种编程模式，通过将任务分解为多个子任务，并在后台或并行线程中执行这些子任务，以提高程序的性能和响应能力。

一、继承 Thread 类实现异步

1、继承Thread子类需要用到的方法

方法名	说明
void run()	在线程开启后，此方法将被调用执行，不能直接调用该方法实现多线程
void start()	使此方法开启一个新线程并开始执行，Java虚拟机会自动调用 run方法

2、实现步骤

定义一个类MyThread继承Thread类
在MyThread类中重写run()方法
创建MyThread类的对象
启动线程

3、举个例子

public class MyThreadDemo extends Thread {
    @Override
    public void run() {
        Long start = System.currentTimeMillis();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0; i<5; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
        Long end = System.currentTimeMillis();
        System.out.println("线程耗时："+(end-start)+"毫秒");
    }
}

 public static void main(String[] args) {
        Long start = System.currentTimeMillis();
        MyThreadDemo m1 = new MyThreadDemo();
        MyThreadDemo m2 = new MyThreadDemo();
        m1.start();
        m2.start();
        Long end = System.currentTimeMillis();
        System.out.println("总线程耗时："+(end-start)+"毫秒");
    }

实现结果：
在这里插入图片描述
总结： 继承 Thread 类这种实现方式，实现比较简单，但是扩展性差，因为类只能单继承。

二、通过新建匿名线程来实现异步

1、实现方法

new Thread(()->{
	执行代码块;
}).start();

2、举例说明

 Long start = System.currentTimeMillis();
        new Thread(() -> {
            Long start1 = System.currentTimeMillis();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Long end1 = System.currentTimeMillis();
            System.out.println("线程耗时："+(end1-start1)+"毫秒");
        }).start();
        Long end = System.currentTimeMillis();
        System.out.println("总线程耗时："+(end-start)+"毫秒");

实现结果：
在这里插入图片描述
注意： JDK8以上版本支持该方法
【Java异常】 Error:java: Compilation failed: internal java compiler error 的解决方案

三、实现 Runnable 接口

1、需要用到的 Thread 构造方法介绍：

方法名	说明
Thread(Runnable target)	传入实现了 Runnable 接口的类，构造一个 Thread 对象
Thread(Runnable target, String name)	传入实现了 Runnable 接口的类，构造一个名称为 name 的 Thread 对象

2、实现步骤：

定义一个类 MyRunnable 实现 Runnable 接口
在 MyRunnable 类中实现 run() 方法
创建MyRunnable 类的对象
创建 Thread 类的对象，把 MyRunnable 对象作为构造方法的参数
启动线程

3、举例说明

public class AsynchronousThread  implements Runnable {
    @Override
    public void run() {
       Long start =  System.currentTimeMillis();
        try {
            Thread.sleep(1000);
            for (int i = 0; i < 5; i++) {
                System.out.println(i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
       Long end =System.currentTimeMillis();
        System.out.println("异步线程耗时："+(end-start)+"毫秒");
    }
}

public static void main(String[] args) {
        Long start =  System.currentTimeMillis();
        AsynchronousThread at= new AsynchronousThread();
        Thread thread1= new Thread(at);
        Thread thread2 = new Thread(at);
        thread1.start();
        thread2.start();
        Long end =System.currentTimeMillis();
        System.out.println("同步线程耗时："+(end-start)+"毫秒");
    }

实现结果：
在这里插入图片描述

总结： 实现 Runnable 接口、Callable 接口这两种实现方式，实现比较复杂，但是扩展性比较强。

四、实现 Callable 接口

1、相关方法介绍：

方法名	说明
V call()	这是 Callable 接口中要实现的方法，相当于 Runnable 接口中的 run 方法
FutureTask(Callable callable)	使用 Callable 接口实现类实例创建一个 FutureTask，它运行时会调配用 Callable 接口中的 call 方法
V get()	FutureTask实例的 get 方法，可以阻塞代码继续往下执行，直到获取到异步线程中的返回结果为止

2、实现步骤：

定义一个类 MyCallable 实现 Callable 接口
在 MyCallable 类中重实现 call() 方法
创建 MyCallable 类的对象
创建 FutureTask 对象，把 MyCallable 对象作为构造方法的参数
创建 Thread 类的对象，把 FutureTask 对象作为构造方法的参数
启动线程
如果想获取返回值的话，可以调用get方法，就可以获取线程结束之后的结果

3、举例说明

public class CallableThread implements Callable<String> {
    @Override
    public String call() throws Exception {
        Long start =  System.currentTimeMillis();
        try {
            Thread.sleep(1000);
            for (int i = 0; i < 5; i++) {
                System.out.println(i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Long end =System.currentTimeMillis();
        System.out.println("异步线程耗时："+(end-start)+"毫秒");
        return "返回异步线程耗时："+(end-start)+"毫秒";
    }
}

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Long start =  System.currentTimeMillis();
        CallableThread mc = new CallableThread();

        //因为该类实现了String 类型的 Callable 接口
        //所以返回值也是 String 类型，所以创建的是 String 类型的 FutureTask 对象
        FutureTask<String> ft = new FutureTask<>(mc);

        //传入 FutureTask 实例，创建线程对象
        Thread t1 = new Thread(ft);

        //不能在这个地方使用 FutureTask 的 get 方法获取异步线程的返回值，否则程序将卡死在这里。
        //因为 t1 线程还没有执行，所以无法获取到返回值，所以如果执行 get 方法，程序将卡死在这里。
        //String s = ft.get();
        //开启新线程，异步执行 MyCallable 实例中的 call 方法逻辑
        t1.start();
        //这里编写一些实现其它业务逻辑代码进行执行
        //可以做一些其它比较耗时的任务
        //......
        Thread.sleep(2000);
        //获取异步线程的返回值
        String s = ft.get();
        System.out.println(s);
        Long end =System.currentTimeMillis();
        System.out.println("同步线程耗时："+(end-start)+"毫秒");
    }

返回结果：
在这里插入图片描述
总结： 如果想要获取到异步线程中的返回值的话，可以采用实现 Callable 接口这种实现方式。

五、Spring的@Async异步(常用)

1、@Async 注解简介

@Async 注解作用

Spring 框架提供的注解，用于将方法标记为异步执行的方法。它的作用是告诉 Spring 框架在调用被注解的方法时，将其放入线程池中异步执行，而不是阻塞等待方法的完成。

@Async 注解的工作原理

在调用被注解的方法时，Spring 会将该方法的执行转移到线程池中的一个线程进行处理。执行完成后，方法的返回值将通过 Future 或 CompletableFuture 进行封装，以便获取方法的返回结果
源码讲解

2、步骤讲解

在方法上添加@Async，表示此方法是异步方法；
在类上添加@Async，表示类中的所有方法都是异步方法；
使用此注解的类，必须是Spring管理的类；
需要在启动类或配置类中加入@EnableAsync注解，@Async才会生效；
在使用@Async时，如果不指定线程池的名称，也就是不自定义线程池，@Async是有默认线程池的，使用的是Spring默认的线程池SimpleAsyncTaskExecutor。

默认线程池的默认配置如下：

默认核心线程数：8；
最大线程数：Integet.MAX_VALUE；//在并发情况下，会无限制的创建线程
队列使用LinkedBlockingQueue；
容量是：Integet.MAX_VALUE；
空闲线程保留时间：60s；
线程池拒绝策略：AbortPolicy；

3、Spring 已经实现的线程池

SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，默认每次调用都会创建一个新的线程。
SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只适用于不需要多线程的地方。
ConcurrentTaskExecutor：Executor的适配类，不推荐使用。如果ThreadPoolTaskExecutor不满足要求时，才用考虑使用这个类。
SimpleThreadPoolTaskExecutor：是Quartz的SimpleThreadPool的类。线程池同时被quartz和非quartz使用，才需要使用此类。
ThreadPoolTaskExecutor ：最常使用，推荐。其实质是对java.util.concurrent.ThreadPoolExecutor的包装。

4、异步的方法有：

最简单的异步调用，返回值为void
带参数的异步调用，异步方法可以传入参数
存在返回值，常调用返回Future

5、实例讲解

启动类

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

自定义线程池

@Configuration


public class AsyncTaskConfig{
	@Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //核心线程池大小
        //设置核心线程数
        executor.setCorePoolSize(3);
        //最大线程数
        executor.setMaxPoolSize(6);
        //队列容量
        executor.setQueueCapacity(12);
        //活跃时间（秒）
        executor.setKeepAliveSeconds(60);
        //线程名字前缀
        executor.setThreadNamePrefix("SyncHistoryInvoice-");
        //线程拒绝策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //等待所有任务结束后再关闭线程池
        executor.setWaitForTasksToCompleteOnShutdown(true);
        //初始化
        executor.initialize();
        return executor;
    }
}

异步任务

 @Async("taskExecutor")
    public void test() throws Exception {
        long sleep = random.nextInt(10000);
        log.info("开始任务，需耗时：" + sleep + "毫秒");
        Thread.sleep(sleep);
        log.info("完成任务");
        return new AsyncResult<>("test");
    }

调用异步任务

 异步任务类名.test();

拒绝策略

ThreadPoolExecutor.AbortPolicy()抛出java.util.concurrent.RejectedExecutionException异常终止策略是默认的饱和策略；
ThreadPoolExecutor.CallerRunsPolicy()当抛出RejectedExecutionException异常时，会调rejectedExecution方法调用者运行策略实现了一种调节机制，该策略既不会抛弃任务也不会爆出异常，而是将任务退回给调用者，从而降低新任务的流量
ThreadPoolExecutor.DiscardOldestPolicy()抛弃旧的任务；当新提交的任务无法保存到队列中等待执行时将抛弃最旧的任务，然后尝试提交新任务。如果等待队列是一个优先级队列，抛弃最旧的策略将导致抛弃优先级最高的任务，因此AbortPolicy最好不要和优先级队列一起使用。
ThreadPoolExecutor.DiscardPolicy()抛弃当前的任务

四种策略优缺点详解

6、@Async失效的几个原因：

注解@Async的方法不是public方法；
注解@Async的返回值只能为void或Future；
注解@Async方法使用static修饰也会失效；
没在启动类上加@EnableAsync注解；
调用异步方法和@Async调用方法不能在一个类中；原因： 类似于Spring对@Transactional注解时也有类似问题，Spring扫描时具有@Transactional注解方法的类时，是生成一个代理类，由代理类去开启关闭事务，而在同一个类中，方法调用是在类体内执行的，Spring无法截获这个方法调用。即 @Async使用的是动态代理来实现异步调用，因此不能够在同一个类中进行调用。方法一定要从另一个类中调用，也就是从类的外部调用，类的内部调用是无效的，有可能因为调用方法的是对象本身而不是代理对象，因为没有经过Spring容器。
在Async方法上标注@Transactional是没用的，但在Async方法调用的方法上标注@Transcational是有效的；