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