futuretask用法及使用场景介绍

futuretask可用于异步获取执行结果或取消执行任务的场景。通过传入runnable或者callable的任务给futuretask，直接调用其run方法或者放入线程池执行，之后可以在外部通过futuretask的get方法异步获取执行结果，因此，futuretask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，futuretask还可以确保即使调用了多次run方法，它都只会执行一次runnable或者callable任务，或者通过cancel取消futuretask的执行等。

1. futuretask执行多任务计算的使用场景

利用futuretask和executorservice，可以用多线程的方式提交计算任务，主线程继续执行其他任务，当主线程需要子线程的计算结果时，在异步获取子线程的执行结果。

package futuretask; 
import java.util.arraylist; 
import java.util.list; 
import java.util.concurrent.callable; 
import java.util.concurrent.executionexception; 
import java.util.concurrent.executorservice; 
import java.util.concurrent.executors; 
import java.util.concurrent.futuretask; 
public class futuretaskformulticompute { 
  public static void main(string[] args) { 
    futuretaskformulticompute inst=new futuretaskformulticompute(); 
    // 创建任务集合 
    list<futuretask<integer>> tasklist = new arraylist<futuretask<integer>>(); 
    // 创建线程池 
    executorservice exec = executors.newfixedthreadpool(5); 
    for (int i = 0; i < 10; i++) { 
      // 传入callable对象创建futuretask对象 
      futuretask<integer> ft = new futuretask<integer>(inst.new computetask(i, ""+i)); 
      tasklist.add(ft); 
      // 提交给线程池执行任务，也可以通过exec.invokeall(tasklist)一次性提交所有任务; 
      exec.submit(ft); 
    } 
    system.out.println("所有计算任务提交完毕, 主线程接着干其他事情！"); 
    // 开始统计各计算线程计算结果 
    integer totalresult = 0; 
    for (futuretask<integer> ft : tasklist) { 
      try { 
        //futuretask的get方法会自动阻塞,直到获取计算结果为止 
        totalresult = totalresult + ft.get(); 
      } catch (interruptedexception e) { 
        e.printstacktrace(); 
      } catch (executionexception e) { 
        e.printstacktrace(); 
      } 
    } 
    // 关闭线程池 
    exec.shutdown(); 
    system.out.println("多任务计算后的总结果是:" + totalresult); 
  } 
  private class computetask implements callable<integer> { 
    private integer result = 0; 
    private string taskname = ""; 
    public computetask(integer iniresult, string taskname){ 
      result = iniresult; 
      this.taskname = taskname; 
      system.out.println("生成子线程计算任务: "+taskname); 
    } 
    public string gettaskname(){ 
      return this.taskname; 
    } 
    @override 
    public integer call() throws exception { 
      // todo auto-generated method stub 
      for (int i = 0; i < 100; i++) { 
        result =+ i; 
      } 
      // 休眠5秒钟，观察主线程行为，预期的结果是主线程会继续执行，到要取得futuretask的结果是等待直至完成。 
      thread.sleep(5000); 
      system.out.println("子线程计算任务: "+taskname+" 执行完成!"); 
      return result; 
    } 
  } 
} 

2. futuretask在高并发环境下确保任务只执行一次

在很多高并发的环境下，往往我们只需要某些任务只执行一次。这种使用情景futuretask的特性恰能胜任。举一个例子，假设有一个带key的连接池，当key存在时，即直接返回key对应的对象；当key不存在时，则创建连接。对于这样的应用场景，通常采用的方法为使用一个map对象来存储key和连接池对应的对应关系，典型的代码如下面所示：

private map<string, connection> connectionpool = new hashmap<string, connection>(); 
private reentrantlock lock = new reentrantlock(); 
public connection getconnection(string key){ 
  try{ 
    lock.lock(); 
    if(connectionpool.containskey(key)){ 
      return connectionpool.get(key); 
    } 
    else{ 
      //创建 connection 
      connection conn = createconnection(); 
      connectionpool.put(key, conn); 
      return conn; 
    } 
  } 
  finally{ 
    lock.unlock(); 
  } 
} 
//创建connection 
private connection createconnection(){ 
  return null; 
} 

在上面的例子中，我们通过加锁确保高并发环境下的线程安全，也确保了connection只创建一次，然而确牺牲了性能。改用concurrenthash的情况下，几乎可以避免加锁的操作，性能大大提高，但是在高并发的情况下有可能出现connection被创建多次的现象。这时最需要解决的问题就是当key不存在时，创建connection的动作能放在connectionpool之后执行，这正是futuretask发挥作用的时机，基于concurrenthashmap和futuretask的改造代码如下：

private concurrenthashmap<string,futuretask<connection>>connectionpool = new concurrenthashmap<string, futuretask<connection>>(); 
public connection getconnection(string key) throws exception{ 
  futuretask<connection>connectiontask=connectionpool.get(key); 
  if(connectiontask!=null){ 
    return connectiontask.get(); 
  } 
  else{ 
    callable<connection> callable = new callable<connection>(){ 
      @override 
      public connection call() throws exception { 
        // todo auto-generated method stub 
        return createconnection(); 
      } 
    }; 
    futuretask<connection>newtask = new futuretask<connection>(callable); 
    connectiontask = connectionpool.putifabsent(key, newtask); 
    if(connectiontask==null){ 
      connectiontask = newtask; 
      connectiontask.run(); 
    } 
    return connectiontask.get(); 
  } 
} 
//创建connection 
private connection createconnection(){ 
  return null; 
} 

经过这样的改造，可以避免由于并发带来的多次创建连接及锁的出现。

总结

以上就是本文关于futuretask用法及使用场景介绍的全部内容，希望对大家有所帮助。感兴趣的朋友可以参阅：浅谈java多线程处理中future的妙用（附源码）、java利用future及时获取多线程运行结果、java多线程forkjoinpool实例详解等，有什么问题可以随时留言，欢迎各位参阅本站其他相关专题。