接口耗时太久怎么办？适当用点Future做异步~

在JS中，各种回调函数漫天飞，写的代码基本都是异步的，需要靠某个event去trigger。比如点击事件，就是最常见的。但是Java里面做异步就得绕好几弯，还不一定行，需要各种判断和校验，生怕出错。

 

异步执行的好处是显而易见的，比如某个接口需要查好几张表，调很多方法，其中有几个方法是非常耗时的。但是很多代码的做法还是同步的，传统的顺序执行。优点是可读性强，不容易出错。

假如A方法耗时特别长的话，那么整合接口的返回就会很慢。

比如，现在有一个服务，非常耗时。

class AccountService {

//耗时6秒的任务

    List<String> queryAccountInfo(String accountNo) throws InterruptedException {

        ArrayList<String> accountList = new ArrayList<String>();

        accountList.add("A账户--" + accountNo);

        accountList.add("账户状态：正常");

        accountList.add("账户额度：8500");

        Thread.sleep(3000);

        return accountList;

    }

}

对于这种耗时任务，当然是希望他可以单独去跑，他在跑的时候，别影响我去做别的事情。

最简单的思路就是用一个线程，可是这样就有一个问题，啥时候任务完成呢？所以，就挺烦的。还好JDK给我们提供了一个很好的类--FutureTask。

从字面意义上看，他是一个未来任务，构造方法如下：

    /**

      * Creates a {@code FutureTask} that will, upon running, execute the

      * given {@code Callable}.

      *

      * @param  callable the callable task

      * @throws NullPointerException if the callable is null

      */

            public FutureTask(Callable<V> callable){

                if (callable ==null)

                    throw new NullPointerException();

                this.callable =callable;

                this.state=NEW;       // ensure visibility of callable

            }

他接收一个callable对象，还有一个构造器重载：

   /**

     * Creates a {@code FutureTask} that will, upon running, execute the

     * given {@code Runnable}, and arrange that {@code get} will return the

     * given result on successful completion.

     *

     * @param runnable the runnable task

     * @param result the result to return on successful completion. If

     * you don't need a particular result, consider using

     * constructions of the form:

     * {@code Future<?> f = new FutureTask<Void>(runnable, null)}

     * @throws NullPointerException if the runnable is null

     */

    public FutureTask(Runnable runnable, V result) {

        this.callable = Executors.callable(runnable, result);

        this.state = NEW;       // ensure visibility of callable

    }

接收Runnable对象。

嗯，按照一贯的套路，如果是自己设计，肯定会弄一个Runnable属性，可是FutureTask偏偏没有这么做，而是用了适配器模式：

this.callable = Executors.callable(runnable, result);

就是强行把Runnabale对象转换为callable对象。

因为Callable有返回值但是Runnable没有，所以就给一个假的result。换句话说，这个result是你自己传进去的，等任务执行完毕后，再还给你。

下面是一个测试Demo，总体来看，确实可以优化接口的返回时间，代价是需要增加好几个类。

class WrongArgumentException extends Exception {


        public WrongArgumentException(String message){
        
                super(message);
        
        }
}
        
class AccountService {

        //耗时6秒的任务

        List<String> queryAccountInfo(String accountNo)throws InterruptedException{

        ArrayList<String> accountList=new ArrayList<String>();

        accountList.add("A账户--" +accountNo);

        accountList.add("账户状态：正常");

        accountList.add("账户额度：8500");

        Thread.sleep(3000);

        return accountList;

        }

}

class AccountQueryService extends AccountService implements Callable{


private String accountNo;


public AccountQueryService(String accountNo){

        this.accountNo=accountNo;

}


@Override

public Object call()throws Exception{

        if(accountNo==null){

            throw new WrongArgumentException("参数传递错误:accountNo为空！");

        }

        return queryAccountInfo(accountNo);

}

        }

public class TestFutureTask {


    public static void main(String[]args)throws InterruptedException,ExecutionException{
    
    
            long start=System.currentTimeMillis();
    
    
            //创建线程池
    
            ExecutorService newSingleThreadExecutor =Executors.newSingleThreadExecutor();
    
    
            Map<String, Object> result=new java.util.HashMap<String, Object>();
    
    
            //执行耗时操作：查询账户信息 ，直接返回结果，不过现在为空
    
            Future<List> task=newSingleThreadExecutor.submit(new AccountQueryService("5201314"));
    
    
            //不影响主线程，异步线程自己在执行
    
            Thread.sleep(1000);
    
            result.put("cardInfo","主卡信息：奥特曼星球联名卡");
    
    
             //等待异步线程是否结束
    
            int timeout=5000; //接口超时时间5
    
            while(!task.isDone()){
    
                if(System.currentTimeMillis()-start>timeout){
        
                    System.out.println("任务超时，提前结束！");
            
                    result.put("code","-1");
            
                    result.put("msg","task time out!");
            
                    System.out.println(result);
            
                    return;
        
                }
        
                Thread.sleep(100);
    
             //System.out.println("账户查询任务尚未结束，请耐心等到1秒...");
    
            }
    
    
            //获取异步任务的结果
    
            result.put("accountInfo",task.get());
    
            result.put("code","00000");
    
            newSingleThreadExecutor.shutdown(); //关闭线程池
    
            System.out.println(result);
    
            System.out.println("任务总耗时：" +(System.currentTimeMillis()-start)/1000 +"秒");


        }


}

运行结果：

{accountInfo=[A账户--5201314, 账户状态：正常, 账户额度：8500], cardInfo=主卡信息：奥特曼星球联名卡, code=00000}
任务总耗时：3秒

虽然代码还很粗糙，不过效果还是有的。对于那种耗时特别久，而且是多任务的情况，胆子够肥的话可以试试。