java异步请求回调结果

今天遇到一个业务上的新需求，有新旧两个接口。现在业务上要求如果调用旧结果三秒没有返回就调用新的接口。百度了一下啊于是决定使用异步来处理这个需求。
在java 线程中提供了Callable 接口来让我实现有带返回参数的多线程方法。
其中Callable 和Future，FutureTask ，ExecutorService 经常配套使用
下面是Callable 的源码：

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *得到一个结果 或者无法完成抛出一个异常
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

我们可以将需要的进行多线程的任务来实现这个接口。该接口支持lambada

Future 源码：

public interface Future<V> {

    /**
     * 企图阻止该任务的执行。这可能会失败如果任务已经执行完毕的话或者已经被取消。
     */
    boolean cancel(boolean mayInterruptIfRunning);

    /**
     * Returns {@code true} if this task was cancelled before it completed
     * normally.
     * 判断任务是否在完成前被取消
     */
    boolean isCancelled();

    /**
     * Returns {@code true} if this task completed.
     * 判断任务是否完成
     */
    boolean isDone();

    /**
     * Waits if necessary for the computation to complete, and then
     * retrieves its result.
     * 获取到任务的返回结果。执行该方法的时候将会阻塞线程。
    V get() throws InterruptedException, ExecutionException;

    /**
     * Waits if necessary for at most the given time for the computation
     * to complete, and then retrieves its result, if available.
     *等到一段指定的时间，如果任务没有返回则抛出超时异常
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

我们可以通过该接口或者其实现类来判断任务是否已经完成
通常使用的子类为 FutureTask。当然使用方式也有点不一样。
ExecutorService 线程池就不多介绍了
来演示第一个demo：

• 首先创建一个异步任务：

package cn.myproject.hzq.ansy;

import java.util.concurrent.Callable;

/**
 * 创建一个异步任务
 * @author hzq
 **/
public class AsyncTask implements Callable<Object> {
    @Override
    public Object call() throws Exception {
        System.out.println("异步线程执行");
        for(int i = 0 ; i < 10 ; i++){
            System.out.println("这时第"+i+"个循环");
            Thread.sleep(100);
        }
        System.out.println("异步线程执行完毕");
        return 1;
    }
}

再来创建一个测试例子

package cn.myproject.hzq.ansy;

import java.util.concurrent.*;

/**
 * @author hzq
 **/
public class FutureTest {

    public static void main(String[] args){
        ExecutorService executorService =
                new ScheduledThreadPoolExecutor(5);
        AsyncTask task = new AsyncTask();
        //添加线程后会自己执行
        Future future = executorService.submit(task);
        try {
            Thread.sleep(100);
            System.out.println("主线程正在执行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            future.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("主线程执行完毕");
        //关闭线程池。当然只是测试的时候需要，真实代码根据实际选择是否要关闭
        executorService.shutdown();
    }
}

在里面使用了Future的 第一种get 方式输出的结果为
异步线程执行
这时第0个循环
这时第1个循环
主线程正在执行
这时第2个循环
这时第3个循环
这时第4个循环
这时第5个循环
这时第6个循环
这时第7个循环
这时第8个循环
这时第9个循环
异步线程执行完毕
主线程执行完毕
现在使用第二种get 方式

package cn.myproject.hzq.ansy;

import java.util.concurrent.*;

/**
 * @author hzq
 **/
public class FutureTest {

    public static void main(String[] args){
        //创建线程池
        ExecutorService executorService =
                new ScheduledThreadPoolExecutor(5);
        AsyncTask task = new AsyncTask();
        //添加线程后会自己执行
        Future future = executorService.submit(task);
        try {
            //主线程休眠
            Thread.sleep(100);
            System.out.println("主线程正在执行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            //100ms 等待获取结果
            future.get(100,TimeUnit.MILLISECONDS);
        } catch (InterruptedException | ExecutionException | TimeoutException e) {
            System.out.println("等待超时抛出异常，继续执行主线程");
            e.printStackTrace();
        }
        System.out.println("主线程执行完毕");
        //关闭线程池。当然只是测试的时候需要，真实代码根据实际选择是否要关闭
        executorService.shutdown();
    }
}

输出：
异步线程执行
这时第0个循环
这时第1个循环
主线程正在执行
这时第2个循环
等待超时抛出异常，继续执行主线程
java.util.concurrent.TimeoutException
at java.util.concurrent.FutureTask.get(FutureTask.java:205)
at cn.myproject.hzq.ansy.FutureTest.main(FutureTest.java:26)
主线程执行完毕
这时第3个循环
这时第4个循环
这时第5个循环
这时第6个循环
这时第7个循环
这时第8个循环
这时第9个循环
异步线程执行完毕

• 使用FutureTask

package cn.myproject.hzq.ansy;

import java.util.concurrent.*;

/**
 * @author hzq
 **/
public class FutureTaskTest {

    public static void main(String[] args){
        //创建线程池
        ExecutorService executorService =
                new ScheduledThreadPoolExecutor(5);
        AsyncTask task = new AsyncTask();
        //添加进入到FutureTask 中
        FutureTask<Object> futureTask =
                new FutureTask<>(task);
        //添加到线程池
        executorService.submit(futureTask);
        try {
            //主线程休眠
            Thread.sleep(100);
            System.out.println("主线程正在执行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            //100ms 等待获取结果
            futureTask.get(100, TimeUnit.MILLISECONDS);
        } catch (InterruptedException | ExecutionException | TimeoutException e) {
            System.out.println("等待超时抛出异常，继续执行主线程");
            e.printStackTrace();
        }
        System.out.println("主线程执行完毕");
        //关闭线程池。当然只是测试的时候需要，真实代码根据实际选择是否要关闭
        executorService.shutdown();
    }
}

执行结果
异步线程执行
这时第0个循环
这时第1个循环
主线程正在执行
这时第2个循环
等待超时抛出异常，继续执行主线程
java.util.concurrent.TimeoutException
at java.util.concurrent.FutureTask.get(FutureTask.java:205)
at cn.myproject.hzq.ansy.FutureTaskTest.main(FutureTaskTest.java:27)
主线程执行完毕
这时第3个循环
这时第4个循环
这时第5个循环
这时第6个循环
这时第7个循环
这时第8个循环
这时第9个循环
异步线程执行完毕

—与future差不多，就是比future 多了一些方法