`
1028826685
  • 浏览: 940704 次
  • 性别: Icon_minigender_1
  • 来自: 重庆
社区版块
存档分类

FutureTask的用法及两种常用的使用场景

 
阅读更多

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

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

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

 

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. package futuretask;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5. import java.util.concurrent.Callable;  
  6. import java.util.concurrent.ExecutionException;  
  7. import java.util.concurrent.ExecutorService;  
  8. import java.util.concurrent.Executors;  
  9. import java.util.concurrent.FutureTask;  
  10.   
  11. public class FutureTaskForMultiCompute {  
  12.       
  13.     public static void main(String[] args) {  
  14.           
  15.         FutureTaskForMultiCompute inst=new FutureTaskForMultiCompute();  
  16.         // 创建任务集合  
  17.         List<FutureTask<Integer>> taskList = new ArrayList<FutureTask<Integer>>();  
  18.         // 创建线程池  
  19.         ExecutorService exec = Executors.newFixedThreadPool(5);  
  20.         for (int i = 0; i < 10; i++) {  
  21.             // 传入Callable对象创建FutureTask对象  
  22.             FutureTask<Integer> ft = new FutureTask<Integer>(inst.new ComputeTask(i, ""+i));  
  23.             taskList.add(ft);  
  24.             // 提交给线程池执行任务,也可以通过exec.invokeAll(taskList)一次性提交所有任务;  
  25.             exec.submit(ft);  
  26.         }  
  27.           
  28.         System.out.println("所有计算任务提交完毕, 主线程接着干其他事情!");  
  29.   
  30.         // 开始统计各计算线程计算结果  
  31.         Integer totalResult = 0;  
  32.         for (FutureTask<Integer> ft : taskList) {  
  33.             try {  
  34.                 //FutureTask的get方法会自动阻塞,直到获取计算结果为止  
  35.                 totalResult = totalResult + ft.get();  
  36.             } catch (InterruptedException e) {  
  37.                 e.printStackTrace();  
  38.             } catch (ExecutionException e) {  
  39.                 e.printStackTrace();  
  40.             }  
  41.         }  
  42.   
  43.         // 关闭线程池  
  44.         exec.shutdown();  
  45.         System.out.println("多任务计算后的总结果是:" + totalResult);  
  46.   
  47.     }  
  48.   
  49.     private class ComputeTask implements Callable<Integer> {  
  50.   
  51.         private Integer result = 0;  
  52.         private String taskName = "";  
  53.           
  54.         public ComputeTask(Integer iniResult, String taskName){  
  55.             result = iniResult;  
  56.             this.taskName = taskName;  
  57.             System.out.println("生成子线程计算任务: "+taskName);  
  58.         }  
  59.           
  60.         public String getTaskName(){  
  61.             return this.taskName;  
  62.         }  
  63.           
  64.         @Override  
  65.         public Integer call() throws Exception {  
  66.             // TODO Auto-generated method stub  
  67.   
  68.             for (int i = 0; i < 100; i++) {  
  69.                 result =+ i;  
  70.             }  
  71.             // 休眠5秒钟,观察主线程行为,预期的结果是主线程会继续执行,到要取得FutureTask的结果是等待直至完成。  
  72.             Thread.sleep(5000);  
  73.             System.out.println("子线程计算任务: "+taskName+" 执行完成!");  
  74.             return result;  
  75.         }  
  76.     }  
  77. }  

 

 

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

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

 

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private Map<String, Connection> connectionPool = new HashMap<String, Connection>();  
  2. private ReentrantLock lock = new ReentrantLock();  
  3.   
  4. public Connection getConnection(String key){  
  5.     try{  
  6.         lock.lock();  
  7.         if(connectionPool.containsKey(key)){  
  8.             return connectionPool.get(key);  
  9.         }  
  10.         else{  
  11.             //创建 Connection  
  12.             Connection conn = createConnection();  
  13.             connectionPool.put(key, conn);  
  14.             return conn;  
  15.         }  
  16.     }  
  17.     finally{  
  18.         lock.unlock();  
  19.     }  
  20. }  
  21.   
  22. //创建Connection  
  23. private Connection createConnection(){  
  24.     return null;  
  25. }  


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

 

 

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. private ConcurrentHashMap<String,FutureTask<Connection>>connectionPool = new ConcurrentHashMap<String, FutureTask<Connection>>();  
  2.   
  3. public Connection getConnection(String key) throws Exception{  
  4.     FutureTask<Connection>connectionTask=connectionPool.get(key);  
  5.     if(connectionTask!=null){  
  6.         return connectionTask.get();  
  7.     }  
  8.     else{  
  9.         Callable<Connection> callable = new Callable<Connection>(){  
  10.             @Override  
  11.             public Connection call() throws Exception {  
  12.                 // TODO Auto-generated method stub  
  13.                 return createConnection();  
  14.             }  
  15.         };  
  16.         FutureTask<Connection>newTask = new FutureTask<Connection>(callable);  
  17.         connectionTask = connectionPool.putIfAbsent(key, newTask);  
  18.         if(connectionTask==null){  
  19.             connectionTask = newTask;  
  20.             connectionTask.run();  
  21.         }  
  22.         return connectionTask.get();  
  23.     }  
  24. }  
  25.   
  26. //创建Connection  
  27. private Connection createConnection(){  
  28.     return null;  
  29. }  


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

分享到:
评论

相关推荐

    JAVA面 试 题 目 总结文档

    - 内部类:包括成员内部类、局部内部类、匿名内部类的概念和使用场景。 3. **集合框架** - List、Set、Queue和Map接口的理解及其实现类的使用。 - ArrayList、LinkedList、HashSet、HashMap等容器的性能特点和...

    java_concurrency_in_practice_source源代码

    源代码中可能会展示这两种方式的使用,以及如何启动线程、控制线程执行和终止线程。 2. **线程同步**:为了防止多个线程对共享资源的竞态条件,Java提供了`synchronized`关键字,它可以用于方法或代码块,实现互斥...

    北京圣思园科技有限公司JAVA面授培训大纲

    - **TCP与UDP**:比较这两种协议的特点和适用场景。 - **Java Collection API**:深入分析Collection、List、Set、Map等接口及其具体实现类的使用方法。 - **数据结构与集合框架**:结合数据结构的知识深入理解Java ...

    JAVA高质量并发详解,多线程并发深入讲解

    介绍`CyclicBarrier`的功能,包括其提供的方法及如何使用它来同步多个线程的操作。 - **第19章:JMH性能测试** 介绍如何使用Java Microbenchmark Harness (JMH)进行微基准测试,涉及`BenchmarkMode`、`Fork`、`...

    Java并发编程实践-电子书-03章

    - **3.3.3 CopyOnWriteArrayList和CopyOnWriteArraySet**:这两种集合类型在执行修改操作时,不会直接修改原始集合,而是创建一个新的副本。这种方法在读多写少的应用场景中特别有效。 #### 3.4 同步器 - **3.4.1 ...

    Java并发编程实战

    - **`Thread.sleep()`与`Thread.yield()`的合理使用:** 分析这两种方法的作用和潜在风险,指导如何在适当的时候使用它们。 - **并发单元测试技巧:** 提供实用的并发测试策略,帮助确保并发程序的正确性和稳定性。 ...

    Java后端常见面试题.zip

    - **线程池**:ExecutorService、ThreadPoolExecutor、FutureTask等的使用和配置优化。 4. **并发编程** - **并发容器**:ConcurrentHashMap、CopyOnWriteArrayList等并发安全的容器使用。 - **并发工具类**:...

    Java Core及底层面试问题.pdf

    - 内部类可以避免修改接口而实现同一个类中两种同名方法的调用。 4. **继承**: - 子类可以从父类继承public和protected修饰的属性和方法,无论子类和父类是否在同一个包内。 - 子类还可以继承默认权限修饰符修饰...

    Java架构面试专题汇总(含答案)和学习笔记

    - **并发工具类**:CountDownLatch、CyclicBarrier、Semaphore、FutureTask等的使用场景和实现原理。 - **原子操作类**:AtomicInteger、AtomicReference等原子类的理解及其在并发中的应用。 4. **Spring框架** ...

    Java经典面试题收集

    此外,ReentrantLock还支持公平和非公平两种模式,公平模式保证了按请求顺序获取锁,而非公平模式则可能允许后来的线程先获取锁。 8. **Java中的CountDownLatch是什么?它通常用于什么场景?** - **答案:** ...

    Java 线程开发讲座

    - **使用场景**:适用于状态单一、更新频繁的场景,如标记位。 - **示例代码**: ```java public class VolatileExample { private volatile boolean flag = false; public void setFlag(boolean flag) { ...

    Java基础整理

    - **Swing和AWT**:Java提供的两种GUI编程框架,其中Swing更加流行。 #### 第十章 网络编程 - **基本概念**:网络编程涉及在网络环境中进行数据交换的过程。 - **Socket编程**:通过Socket建立客户端与服务器之间...

    多线程单例模式并发访问

    3. **实现Callable接口**:自Java 1.5开始,可以使用`Callable`接口结合`FutureTask`来创建有返回值的线程。 #### 四、启动线程 启动线程时,应当使用`Thread`对象的`start()`方法,而不是直接调用`run()`方法。这...

    Java并发编程(学习笔记).xmind

    (3)使用信号量将任何一种容器变成有界阻塞容器 栅栏 能够阻塞一组线程直到某个事件发生 栅栏和闭锁的区别 所有线程必须同时到达栅栏位置,才能继续执行 闭锁用于等待事件,而栅栏...

    Java并发编程实战(中文版).7z

    1. **线程创建**:Java提供了两种方式创建线程——继承Thread类和实现Runnable接口。继承Thread类直接创建线程对象,而实现Runnable接口则可以避免单继承的限制,更利于代码的复用。 2. **线程同步**:在并发环境中...

    java最经典面试题.doc

    #### 十一、在JSP中的两种跳转方式及区别 - **转发(forward)**:使用`&lt;jsp:forward page="..."/&gt;`标签或`RequestDispatcher.forward(request, response)`方法。 - 请求域数据保留。 - 地址栏不变。 - **重定向...

    大唐JAVA笔试题

    - 分为Stateless和Stateful两种。 - **Entity Beans**: - 用于持久化数据,对应数据库表。 - **Message-driven Beans**: - 用于处理异步消息。 #### 16. SessionBean包含的组件及其作用 - **Home Interface**: ...

    java面试题2024资源下载

    - 提供了独占式和共享式两种同步器模板。 #### 八、notify()与notifyAll()的区别 - **notify()**: - 唤醒等待队列中的一个线程。 - 需要注意的是,哪个线程被唤醒是非确定性的。 - **notifyAll()**: - 唤醒...

    2020面试题总结多线程篇.pdf

    多线程实现方式主要有四种:继承 Thread 类、实现 Runable 接口、实现 Callable 接口、通过 FutureTask 包装器。这四种方式可以满足不同的需求,例如继承 Thread 类可以实现线程的生命周期管理,而实现 Runable 接口...

    Java面试题和答案.pdf

    - 死锁是指两个或多个线程在执行过程中因争夺资源而造成的一种互相等待的现象,若无外力作用,这些线程都将无法推进下去。 **50. 怎么防止死锁?** - 使用锁顺序规则:总是按照相同的顺序获取锁。 - 使用锁超时:...

Global site tag (gtag.js) - Google Analytics