java 真正的异步处理

  • 常规的异步处理
  • 真正的异步处理（future -> listen机制）

常规的异步处理

常规的异步处理，网上介绍的或者是大家用的一般都是FutureTask+Callable，这是jUC中提出的内容。直接上代码来看：
新建一个FutureTaskExample，如下所示：

public class FutureTaskExample {
    public static void main(String[] args) {
        MyCallable callable1 = new MyCallable(1000);                       // 要执行的任务
        MyCallable callable2 = new MyCallable(2000);

        FutureTask<String> futureTask1 = new FutureTask<String>(callable1);// 将Callable写的任务封装到一个由执行者调度的FutureTask对象
        FutureTask<String> futureTask2 = new FutureTask<String>(callable2);

        ExecutorService executor = Executors.newFixedThreadPool(2);        // 创建线程池并返回ExecutorService实例
        executor.execute(futureTask1);  // 执行任务
        executor.execute(futureTask2);

        while (true) {
            try {
                if(futureTask1.isDone() && futureTask2.isDone()){//  两个任务都完成
                    System.out.println("Done");
                    executor.shutdown();                          // 关闭线程池和服务
                    return;
                }

                if(!futureTask1.isDone()){ // 任务1没有完成，会等待，直到任务完成
                    System.out.println("FutureTask1 output="+futureTask1.get());
                }

                System.out.println("Waiting for FutureTask2 to complete");
                String s = futureTask2.get(200L, TimeUnit.MILLISECONDS);
                if(s !=null){
                    System.out.println("FutureTask2 output="+s);
                }
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }catch(TimeoutException e){
                //do nothing
            }
        }
    }
}

建立MyCallable 类，如下所示：

public class MyCallable implements Callable<String> {

    private long waitTime;
    public MyCallable(int timeInMillis){
        this.waitTime=timeInMillis;
    }
    @Override
    public String call() throws Exception {
        System.out.println("任务开始    ");
        Thread.sleep(waitTime);
//        for (int i = 0; i < 10000; i++) {
//            System.out.println(Thread.currentThread().getName()+" =====任务开始");
//        }
        //return the thread name executing this callable task
        return Thread.currentThread().getName();
    }

}

在程序运行过程中，利用Callable返回值，来监听Callable是否运行完成，简单来说，Callable就是带返回值的Runnable，另外有自己的异常抛出，如果不懂Callable的同学，可以私下自己看一下javaJUC。利用Future接口的 boolean isDone(); 方法来阻塞监听
Callable是否完成，这里一定要注意是阻塞。也就是说，如果你想要知道Callable是否完成，其实你一直都在boolean isDone();等待，并不能真正实现futuer -> listen机制，即执行完之后直接返回回调，不用认为的去等待返回结果。

真正的异步处理（future -> listen机制）

这个思想来源于事件驱动处理机制，想深入的想过自己写一个真正的futuer -> listen，但是后来在google看到这个的jar包，就拿来分享一下，具体的实现如下所示：
在pom.xml文件中添加以下依赖

<dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>28.1-jre</version>
            <scope>compile</scope>
        </dependency>

编写如下测试类：

import com.google.common.util.concurrent.*;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureListen {
    public static void main(String[] args) {

        MyCallable callable1 = new MyCallable(1000*10);                       // 要执行的任务
        FutureTask<String> futureTask1 = new FutureTask<String>(callable1);// 将Callable写的任务封装到一个由执行者调度的FutureTask对象

        ExecutorService executor = Executors.newFixedThreadPool(2);        // 创建线程池并返回ExecutorService实例
        executor.execute(futureTask1);

        // futureTask转换成ListenableFuture
        ListenableFuture<String> listenableFuture = JdkFutureAdapters.listenInPoolThread(futureTask1);
        // 监听返回结果
        Futures.addCallback(listenableFuture, new FutureCallback<String>() {
            @Override
            public void onSuccess(String result) {
                System.out.println("任务结果: 正常执行完成 -- " + result);
            }

            @Override
            public void onFailure(Throwable t) {
                System.out.println("任务结果: 抛异常了");
            }
        }, MoreExecutors.directExecutor());

    }
}

这里利用Futures.addCallback来实现监听，当任务执行完成的时候，会自动调用对应的成功和失败函数，真正的实现futuer -> listen机制。