在Java多线程之中,CallableFuture的使用时非常广泛的。在之前的文章中,我们了解了关于Java线程池基础的一些内容,知道如何提交Runnable的任务。但是,Runnable的任务是无法有返回值,也不能抛出异常的。而有些时候,我们希望一个线程能够有一些返回值。在Java 5中,引入了java.util.concurrent.Callable接口,这个接口很类似于Runnable接口,但是可以返回一个对象,或者抛出异常。

Java Callable

Java的Callable接口使用了泛型来定义返回的对象的类型。Executors类提供了一些很实用的方法来在线程池中执行Callable的任务。因为Callable的任务通过并行的方式来运行,所以我们需要等待返回的对象。

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;
}

Java Future

Java的Callable对象返回的就是java.util.concurrent.Future对象。通过使用Java Future对象,我们可以知道Callable任务的执行状态,并且获得返回的对象。Future接口提供get()方法来让开发者可以等待Callable任务的执行,然后获得对应的结果。

public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning); boolean isCancelled(); boolean isDone(); V get() throws InterruptedException, ExecutionException; V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}

Java Future提供了一个cancel()方法来取消关联的Callable任务的执行。其中的get()方法是包含一个重载的方法的,我们可以指定等待的时间,而不需要无限期的等待Callable任务的执行。这个方法可以有效的防止一个线程的无限期的阻塞。

Future也提供一个isDone()和一个isCancelled()方法来找到其关联的Callable任务的执行状态。

下面是使用Callable的例子,是在一秒之后返回执行任务的名字。我们通过使用Executor框架来并行执行100个任务,然后用Future来获得任务的执行结果。

package com.sapphire.threads;

import java.util.ArrayList;
import java.util.Date;
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.Future; public class MyCallable implements Callable<String> { @Override
public String call() throws Exception {
Thread.sleep(1000);
//return the thread name executing this callable task
return Thread.currentThread().getName();
} public static void main(String args[]){
//Get ExecutorService from Executors utility class, thread pool size is 10
ExecutorService executor = Executors.newFixedThreadPool(10);
//create a list to hold the Future object associated with Callable
List<Future<String>> list = new ArrayList<Future<String>>();
//Create MyCallable instance
Callable<String> callable = new MyCallable();
for(int i=0; i< 100; i++){
//submit Callable tasks to be executed by thread pool
Future<String> future = executor.submit(callable);
//add Future to the list, we can get return value using Future
list.add(future);
}
for(Future<String> fut : list){
try {
//print the return value of Future, notice the output delay in console
// because Future.get() waits for task to get completed
System.out.println(new Date()+ "::"+fut.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
//shut down the executor service now
executor.shutdown();
}
}

当我们运行上面程序的时候,我们的输出会有延迟,因为Future的get()方法会一直等待Callable的任务执行完毕。同时需要注意的是,线程池中,我们仅仅会有10个线程来处理之前定义的Callable任务。

下面是上面程序的输出结果:

Mon Dec 31 20:40:15 PST 2012::pool-1-thread-1
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-2
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-3
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-4
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-5
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-6
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-7
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-8
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-9
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-10
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-2
...

当我们想要覆盖掉Future接口的一些行为的时候,举例来说,假设我们需要覆盖其中的get()方法来做一些超时处理而不进行持续等待等操作的时候。Java中的FutureTask类在这种时候就会非常有用了,它是Future接口的实现类。

FutureTask

在上面,我们了解到使用Callable以及Future接口来处理多线程的一些便利之处。

FutureTaskFuture接口的一个基础实现,并且提供了异步处理的功能,FutureTask包含了一些方法来启动或者取消任务,也包含一些方法来返回Future的状态,来确认Future是完成了还是去掉了。我们需要一个Callable对象来创建一个FutureTask然后,我们可以通过ThreadPoolExecutor来异步处理这些任务。

下面是FutureTask的代码举例,因为FutureTask是需要Callable的,所以我们来创建一个Callable的实现:

package com.sapphire.threads;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {

    private long waitTime;

    public MyCallable(int timeInMillis){
this.waitTime=timeInMillis;
}
@Override
public String call() throws Exception {
Thread.sleep(waitTime);
//return the thread name executing this callable task
return Thread.currentThread().getName();
} }

下面是一个FutureTask方法的例子,下面展示的是关于使用FutureTask方法的一些举例:

package com.sapphire.threads;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException; public class FutureTaskExample { public static void main(String[] args) {
MyCallable callable1 = new MyCallable(1000);
MyCallable callable2 = new MyCallable(2000); FutureTask<String> futureTask1 = new FutureTask<String>(callable1);
FutureTask<String> futureTask2 = new FutureTask<String>(callable2); ExecutorService executor = Executors.newFixedThreadPool(2);
executor.execute(futureTask1);
executor.execute(futureTask2); while (true) {
try {
if(futureTask1.isDone() && futureTask2.isDone()){
System.out.println("Done");
//shut down executor service
executor.shutdown();
return;
} if(!futureTask1.isDone()){
//wait indefinitely for future task to complete
System.out.println(
"FutureTask1 output="+futureTask1.get());
} System.out.println("Waiting for FutureTask2 to complete");
String s = futureTask2.get(200L, TimeUnit.MILLISECONDS);
if(s !=null){
System.out.println("FutureTask2 output="+s);
}
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}catch(TimeoutException e){
//do nothing
}
}
}
}

当我们运行上面的程序,你会发现,有一段时间是不会输出任何东西到控制台的,因为FutureTaskget()方法会等待任务的完成,然后才会返回输出的对象。在FutureTask中也有一个重载的方法会等待指定的时间。需要注意的是,当调用isDone()方法来确定程序一旦结束,任务也会完成。

输出如下:

FutureTask1 output=pool-1-thread-1
Waiting for FutureTask2 to complete
Waiting for FutureTask2 to complete
Waiting for FutureTask2 to complete
Waiting for FutureTask2 to complete
Waiting for FutureTask2 to complete
FutureTask2 output=pool-1-thread-2
Done

从上面的例子来说是没有使用到FutureTask的便利之处的,但是当我们想要覆盖掉Future接口方法的实现,而不像实现Future接口的每一个方法的时候,我们就可以考虑使用FutureTask

Java线程和多线程(十三)——Callable,Future,FutureTask的更多相关文章

  1. Java多线程:Callable,Future,FutureTask

    一.Future Future和Callable基本是成对出现的,Callable负责产生结果,Future负责获取结果.     1.Callable接口类似于Runnable,只是Runnable ...

  2. Java 并发编程——Callable+Future+FutureTask

    Java 并发编程系列文章 Java 并发基础——线程安全性 Java 并发编程——Callable+Future+FutureTask java 并发编程——Thread 源码重新学习 java并发 ...

  3. Java并发编程:ThreadPoolExecutor + Callable + Future(FutureTask) 探知线程的执行状况

    如题 (总结要点) 使用ThreadPoolExecutor来创建线程,使用Callable + Future 来执行并探知线程执行情况: V get (long timeout, TimeUnit ...

  4. java 并发runable,callable,future,futureTask

    转载自:http://www.cnblogs.com/dolphin0520/p/3949310.html package future_call; import java.util.concurre ...

  5. JAVA线程池中的Callable和Future

    import java.util.Random; import java.util.concurrent.Callable; import java.util.concurrent.Completio ...

  6. Java多线程的Callable, Future, FutureCallback

    Callable可以看成是一个增强版的Runnable, 带返回结果, 需要通过Future或者FutureTask来提交任务或运行线程, 然后通过Future/FutureTask的get方法得到返 ...

  7. Java线程与多线程教程

    本文由 ImportNew - liken 翻译自 Journaldev.   Java线程是执行某些任务的轻量级进程.Java通过Thread类提供多线程支持,应用可以创建并发执行的多个线程. 应用 ...

  8. Java 线程与多线程

    Java是一门支持多线程的编程语言! 什么是进程? 计算机中内存.处理器.IO等资源操作都要为进程进行服务. 一个进程上可以创建多个线程,线程比进程更快的处理单元,而且所占用的资源也小,多线程的应用也 ...

  9. 12 Callable & Future & FutureTask

    创建线程的2种方式,一种是直接继承Thread,另外一种就是实现Runnable接口. 这2种方式都有一个缺陷就是:在执行完任务之后无法获取执行结果. 如果需要获取执行结果,就必须通过共享变量或者使用 ...

随机推荐

  1. JAVA Color类

    Color类用于定义颜色,java.awt.Color中提供了13个预定义的常量用来表示13中标准颜色,分别是: public static final Color white白色. public s ...

  2. 高性能 Socket 组件 HP-Socket v3.2.1-RC3 公布

    HP-Socket 是一套通用的高性能 TCP/UDP Socket 组件,包括服务端组件.client组件和 Agent 组件,广泛适用于各种不同应用场景的 TCP/UDP 通信系统.提供 C/C+ ...

  3. kubernetes 入门学习

    kubernetes 学习 kubernetes 简介 Kubernetes这个名字源自希腊语,意思是"舵手",也是"管理者","治理者"等 ...

  4. 【[NOI2009]管道取珠】

    --\(shallwe\):这道题是\(noipDay2T2\)难度 好一个\(Day2T2\)难度啊,我觉得我可以退役了 平方和好像没有什么办法可以快速统计,于是考虑转化一下 我们可以将题意转化成这 ...

  5. Calabash(葫芦娃)

    嘟嘟嘟 第一眼就觉得肯定某种是最短路,然后想了半天也不知道.然后就把送的50分写了,然后就爆搜,结果因为一个错误的剪枝竟然90分?!只能怪数据太水…… 考完试后听bin哥讲,说就是普通的最短路,只不过 ...

  6. H、CSL 的拼图 【多维点的交换】 (“新智认知”杯上海高校程序设计竞赛暨第十七届上海大学程序设计春季联赛)

    题目传送门:https://ac.nowcoder.com/acm/contest/551/H 题目描述 众所周知 CSL 不仅玩魔方很强,打麻将也很强.今天他打魔法麻将的时候,在路上撞到了一个被打乱 ...

  7. [Python 多线程] multiprocessing、多进程、工作进程池 (十四)

    由于Python的GIL限制,多线程未必是CPU密集型程序的好的选择. 多进程可以完全独立的进程环境中运行程序,可以充分地利用多处理器. 但是进程本身的隔离性带来的数据不共享也是一个问题.而且线程比进 ...

  8. ethereumjs/ethereumjs-vm-4-tests

    根据代码发现还要了解的模块有: ethereumjs/merkle-patricia-tree -对应数据存储的数据结构 ethereumjs-blockchain —— 区块链 ethereumjs ...

  9. SpringBoot实战(十一)之与JMS简单通信

    什么是JMS? 引用百度百科上的说明: JMS即Java消息服务(Java Message Service)应用程序接口,是一个Java平台中关于面向消息中间件(MOM)的API,用于在两个应用程序之 ...

  10. PAT——1042. 字符统计

    请编写程序,找出一段给定文字中出现最频繁的那个英文字母. 输入格式: 输入在一行中给出一个长度不超过1000的字符串.字符串由ASCII码表中任意可见字符及空格组成,至少包含1个英文字母,以回车结束( ...