在多线程的编程中你是否也为不知道其他线程是否已经结束、得不到其他线程的执行结果而苦恼。今天我们来看的FutureTask就解决了这个问题。
FutureTask:一种可以携带结果的Runnable.它的计算是通过Callable的call方法来实现的。
我们来看一下FutureTask的构造.
public class FutureTask<V> implements RunnableFuture<V>
可以看到它实现了RunnableFuture接口.
public interface RunnableFuture<V> extends Runnable, Future<V>
而RunnableFuture又实现了Runnable和Future。
Runnable接口想必大家都非常熟悉了。我们来看下Future接口
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;
}
cancel(boolean mayInterruptIfRunning) | 取消任务,如果mayInterruptIfRunning设置为true,标识可以取消正在进行中的任务.返回值分为三种情况:1.任务执行中,当mayInterruptIfRunning为true时,返回true.当mayInterruptIfRunning为false时候返回false.2.任务已经完成.无论mayInterruptIfRunning为true or false 都返回false.3.任务未运行 .无论mayInterruptIfRunning为true or false 都返回true |
isCancelled() | 任务是否被成功取消 |
isDone() | 任务是否已经完成.取消、异常、完成都属于完成。 |
get() | 阻塞只到有结果返回 |
get(long timeout, TimeUnit unit) | 指定时间内如果没有返回结果则返回NULL |
我们再来看下FutureTask的构造器
public FutureTask(Callable<V> callable) 中有一个Callable参数。上面我们说过FutureTask的计算实际是通过Callable的call方法来实现的。
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;
}
Callable接口中只有一个call方法,而且有返回值,这个返回值就是我们计算所携带的结果。
下面是FutureTask的常见用法:
1.Thread 执行FutureTask
package com.asiainfo.concurrent;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
/**
* 可携带结果的任务.
*
* 实现了Runnable接口
*/
import java.util.concurrent.FutureTask;
/**
* Thread 方式启动FutureTask
* @author fansh
*
*/
public class FutureTaskTest{
static FutureTask<String> future=new FutureTask<String>(new Callable<String>() {
public String call() throws Exception {
return "this is the result!";
};
});
private Thread thread = new Thread(future);
private void start(){
thread.start();
}
public static void main(String[] args) {
FutureTaskTest test =new FutureTaskTest();
test.start();
try {
String result=future.get();
System.out.println(result);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
2. ExecutorService启动FutureTask
package com.asiainfo.concurrent;
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;
/**
* ExecutorService 方式启动FutureTask
* @author fansh
*
*/
public class FutureTaskTest1 {
static FutureTask<String> future = new FutureTask<String>(new Callable<String>(){
public String call(){
return "this is the result!";
}
});
public static void main(String[] args) throws InterruptedException, ExecutionException{
ExecutorService service =Executors.newCachedThreadPool();
service.submit(future);
service.shutdown();
String result=future.get();
System.out.println(result);
}
}
3.FutureTask 任务未启动时 取消任务
package com.asiainfo.concurrent;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
/**
* 1:任务尚未开始
* @author fansh
*
*/
public class FutureTaskCanceledTest {
static FutureTask<String> future=new FutureTask<String>(new Callable<String>() {
public String call() throws Exception {
Thread.sleep(1000);
return "a";
};
});
private Thread thread = new Thread(future);
private void start(){
thread.start();
}
public static void main(String[] args) {
FutureTaskCanceledTest test =new FutureTaskCanceledTest();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//boolean flag =future.cancel(true);
boolean flag =future.cancel(false);
System.out.println("任务是否已经取消:"+flag);
//保证任务取消的时候 线程尚未执行.
test.start();
}
}
4.FutureTask 任务完成后 取消任务
package com.asiainfo.concurrent;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
/**
* 1:任务已经完成
* @author fansh
*
*/
public class FutureTaskCanceledTest1 {
static FutureTask<String> future=new FutureTask<String>(new Callable<String>() {
public String call() {
return "a";
};
});
private Thread thread = new Thread(future);
private void start(){
thread.start();
}
public static void main(String[] args) {
FutureTaskCanceledTest1 test =new FutureTaskCanceledTest1();
test.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
boolean flag=future.cancel(false);
//boolean flag=future.cancel(true);
System.out.println("任务是否已经取消:"+flag);
}
}
5. 任务进行中 响应取消动作
package com.asiainfo.concurrent;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
/**
* 1:任务进行中......
* @author fansh
*
*/
public class FutureTaskCanceledTest2 {
static FutureTask<String> future=new FutureTask<String>(new Callable<String>() {
public String call() {
while(!Thread.currentThread().isInterrupted()){
System.out.println("任务进行中............");
}
return "a";
};
});
private Thread thread = new Thread(future);
private void start(){
thread.start();
}
public static void main(String[] args) {
FutureTaskCanceledTest2 test =new FutureTaskCanceledTest2();
test.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
boolean flag=future.cancel(true);
//boolean flag=future.cancel(false);
System.out.println("任务是否已经取消:"+flag);
}
}
分享到:
相关推荐
主要介绍了Java线程池FutureTask实现原理详解,小编觉得还是挺不错的,具有一定借鉴价值,需要的朋友可以参考下
主要为大家详细介绍了Java中Future、FutureTask原理以及与线程池的搭配使用,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
在本篇文章里我们给大家分享了java中Future与FutureTask之间的关系的内容,有需要的朋友们可以跟着学习下。
主要介绍了简谈java并发FutureTask的实现,FutureTask都是用于获取线程执行的返回结果。文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,,需要的朋友可以参考下
主要介绍了Java中的Runnable,Callable,Future,FutureTask的比较的相关资料,需要的朋友可以参考下
主要介绍了futuretask用法及使用场景介绍,小编觉得挺不错的,这里分享给大家,供大家参考。
主要介绍了Java FutureTask类使用案例解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值析,需要的朋友可以参考下
JAVA线程总结,包含线程池,显示使用线程实现异步编程,基于JDK中的Future实现异步编程,JDK中的FutureTask等
Java 多线程与并发(17_26)-JUC线程池_ FutureTask详解
1、在 java 中守护线程和本地线程区别?2、线程与进程的区别?3、什么是多线程中的上下文切换?4、死锁与活锁的区别,死锁与饥饿的区别?5、Java 中用到的线程调度算法是什么?6、什么是线程组,为什么在 Java 中不...
5.5.2 FutureTask 5.5.3 信号量 5.5.4 栅栏 5.6 构建高效且可伸缩的结果缓存 第二部分 结构化并发应用程序 第6章 任务执行 6.1 在线程中执行任务 6.1.1 串行地执行任务 6.1.2 显式地为任务创建线程 6.1.3 ...
主要介绍了java多线程编程同步器Future和FutureTask解析及代码示例,对二者进行了详细介绍,分析了future的源码,最后展示了相关实例代码,具有一定参考价值 ,需要的朋友可以了解下。
主要介绍了futuretask源码分析(推荐),小编觉得还是挺不错的,这里给大家分享下,供各位参考。
FutureTask底层实现分析,有了FutureTask主线程要想获得工作线程(异步计算线程)的结果变得比较简单
http://blog.csdn.net/yangzhaomuma/article/details/51722779
Java Concurrency Patterns and Features Concurrency Patterns and features found in Java, through multithreaded programming. Features: Threads and Runnables ...FutureTask CompletableFuture Java M
解决线程的死掉问题和超时问题特别好使,在Java中,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分,在java.util.concurrent...
主要介绍了Java多线程下的其他组件之CyclicBarrier、Callable、Future和FutureTask详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
实践学习:Java异步编程(Future、FutureTask、Guava.ListenableFuture、Java8.CompletableFuture等) 在实践中学习:使用 RxJava/Reactor 进行 Java 响应式编程。 一次技术讲座,介绍学习和实践。
5.5.2 FutureTask 5.5.3 信号量 5.5.4 栅栏 5.6 构建高效且可伸缩的结果缓存 第二部分 结构化并发应用程序 第6章 任务执行 6.1 在线程中执行任务 6.1.1 串行地执行任务 6.1.2 显式地为任务创建线程 6.1.3 ...