Java中的Runnable、Callable、Future、FutureTask的区别与示例
原文地址:http://blog.csdn.net/bboyfeiyu/article/details/24851847
---------------------------------------------------------
Java中存在Runnable、Callable、Future、FutureTask这几个与线程相关的类或者接口,在Java中也是比较重要的几个概念,我们通过下面的简单示例来了解一下它们的作用于区别。
Runnable
其中Runnable应该是我们最熟悉的接口,它只有一个run()函数,用于将耗时操作写在其中,该函数没有返回值。然后使用某个线程去执行该runnable即可实现多线程,Thread类在调用start()函数后就是执行的是Runnable的run()函数。Runnable的声明如下 :
- public interface Runnable {
- /**
- * When an object implementing interface <code>Runnable</code> is used
- * to create a thread, starting the thread causes the object's
- * <code>run</code> method to be called in that separately executing
- * thread.
- * <p>
- *
- * @see java.lang.Thread#run()
- */
- public abstract void run();
- }
Callable
Callable与Runnable的功能大致相似,Callable中有一个call()函数,但是call()函数有返回值,而Runnable的run()函数不能将结果返回给客户程序。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;
- }
可以看到,这是一个泛型接口,call()函数返回的类型就是客户程序传递进来的V类型。
Future
Executor就是Runnable和Callable的调度容器,Future就是对于具体的Runnable或者Callable任务的执行结果进行
取消、查询是否完成、获取结果、设置结果操作。get方法会阻塞,直到任务返回结果(Future简介)。Future声明如下 :
- /**
- * @see FutureTask
- * @see Executor
- * @since 1.5
- * @author Doug Lea
- * @param <V> The result type returned by this Future's <tt>get</tt> method
- */
- public interface Future<V> {
- /**
- * Attempts to cancel execution of this task. This attempt will
- * fail if the task has already completed, has already been cancelled,
- * or could not be cancelled for some other reason. If successful,
- * and this task has not started when <tt>cancel</tt> is called,
- * this task should never run. If the task has already started,
- * then the <tt>mayInterruptIfRunning</tt> parameter determines
- * whether the thread executing this task should be interrupted in
- * an attempt to stop the task. *
- */
- boolean cancel(boolean mayInterruptIfRunning);
- /**
- * Returns <tt>true</tt> if this task was cancelled before it completed
- * normally.
- */
- boolean isCancelled();
- /**
- * Returns <tt>true</tt> if this task completed.
- *
- */
- boolean isDone();
- /**
- * Waits if necessary for the computation to complete, and then
- * retrieves its result.
- *
- * @return the computed result
- */
- V get() throws InterruptedException, ExecutionException;
- /**
- * Waits if necessary for at most the given time for the computation
- * to complete, and then retrieves its result, if available.
- *
- * @param timeout the maximum time to wait
- * @param unit the time unit of the timeout argument
- * @return the computed result
- */
- V get(long timeout, TimeUnit unit)
- throws InterruptedException, ExecutionException, TimeoutException;
- }
FutureTask
FutureTask则是一个RunnableFuture<V>,而RunnableFuture实现了Runnbale又实现了Futrue<V>这两个接口,
- public class FutureTask<V> implements RunnableFuture<V>
RunnableFuture
- public interface RunnableFuture<V> extends Runnable, Future<V> {
- /**
- * Sets this Future to the result of its computation
- * unless it has been cancelled.
- */
- void run();
- }
另外它还可以包装Runnable和Callable<V>, 由构造函数注入依赖。
- public FutureTask(Callable<V> callable) {
- if (callable == null)
- throw new NullPointerException();
- this.callable = callable;
- this.state = NEW; // ensure visibility of callable
- }
- public FutureTask(Runnable runnable, V result) {
- this.callable = Executors.callable(runnable, result);
- this.state = NEW; // ensure visibility of callable
- }
可以看到,Runnable注入会被Executors.callable()函数转换为Callable类型,即FutureTask最终都是执行Callable类型的任务。该适配函数的实现如下 :
- public static <T> Callable<T> callable(Runnable task, T result) {
- if (task == null)
- throw new NullPointerException();
- return new RunnableAdapter<T>(task, result);
- }
RunnableAdapter适配器
- /**
- * A callable that runs given task and returns given result
- */
- static final class RunnableAdapter<T> implements Callable<T> {
- final Runnable task;
- final T result;
- RunnableAdapter(Runnable task, T result) {
- this.task = task;
- this.result = result;
- }
- public T call() {
- task.run();
- return result;
- }
- }
由于FutureTask实现了Runnable,因此它既可以通过Thread包装来直接执行,也可以提交给ExecuteService来执行。
并且还可以直接通过get()函数获取执行结果,该函数会阻塞,直到结果返回。因此FutureTask既是Future、
Runnable,又是包装了Callable( 如果是Runnable最终也会被转换为Callable ), 它是这两者的合体。
简单示例
- package com.effective.java.concurrent.task;
- 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;
- import java.util.concurrent.FutureTask;
- /**
- *
- * @author mrsimple
- *
- */
- public class RunnableFutureTask {
- /**
- * ExecutorService
- */
- static ExecutorService mExecutor = Executors.newSingleThreadExecutor();
- /**
- *
- * @param args
- */
- public static void main(String[] args) {
- runnableDemo();
- futureDemo();
- }
- /**
- * runnable, 无返回值
- */
- static void runnableDemo() {
- new Thread(new Runnable() {
- @Override
- public void run() {
- System.out.println("runnable demo : " + fibc(20));
- }
- }).start();
- }
- /**
- * 其中Runnable实现的是void run()方法,无返回值;Callable实现的是 V
- * call()方法,并且可以返回执行结果。其中Runnable可以提交给Thread来包装下
- * ,直接启动一个线程来执行,而Callable则一般都是提交给ExecuteService来执行。
- */
- static void futureDemo() {
- try {
- /**
- * 提交runnable则没有返回值, future没有数据
- */
- Future<?> result = mExecutor.submit(new Runnable() {
- @Override
- public void run() {
- fibc(20);
- }
- });
- System.out.println("future result from runnable : " + result.get());
- /**
- * 提交Callable, 有返回值, future中能够获取返回值
- */
- Future<Integer> result2 = mExecutor.submit(new Callable<Integer>() {
- @Override
- public Integer call() throws Exception {
- return fibc(20);
- }
- });
- System.out
- .println("future result from callable : " + result2.get());
- /**
- * FutureTask则是一个RunnableFuture<V>,即实现了Runnbale又实现了Futrue<V>这两个接口,
- * 另外它还可以包装Runnable(实际上会转换为Callable)和Callable
- * <V>,所以一般来讲是一个符合体了,它可以通过Thread包装来直接执行,也可以提交给ExecuteService来执行
- * ,并且还可以通过v get()返回执行结果,在线程体没有执行完成的时候,主线程一直阻塞等待,执行完则直接返回结果。
- */
- FutureTask<Integer> futureTask = new FutureTask<Integer>(
- new Callable<Integer>() {
- @Override
- public Integer call() throws Exception {
- return fibc(20);
- }
- });
- // 提交futureTask
- mExecutor.submit(futureTask) ;
- System.out.println("future result from futureTask : "
- + futureTask.get());
- } catch (InterruptedException e) {
- e.printStackTrace();
- } catch (ExecutionException e) {
- e.printStackTrace();
- }
- }
- /**
- * 效率底下的斐波那契数列, 耗时的操作
- *
- * @param num
- * @return
- */
- static int fibc(int num) {
- if (num == 0) {
- return 0;
- }
- if (num == 1) {
- return 1;
- }
- return fibc(num - 1) + fibc(num - 2);
- }
- }
输出结果
-------------
更多的Java,Angular,Android,大数据,J2EE,Python,数据库,Linux,Java架构师,:
http://www.cnblogs.com/zengmiaogen/p/7083694.html
Java中的Runnable、Callable、Future、FutureTask的区别与示例相关推荐
- Java并发编程举例Runnable, Callable, Future, FutureTask, CompletionService
import java.util.concurrent.*;/*** Created by chenh on 2017/3/23.*/ public class ConcurrentDemo {// ...
- Java中的Runnable、Callable、Future、FutureTask
Java中存在Runnable.Callable.Future.FutureTask这几个与线程相关的类或者接口,在Java中也是比较重要的几个概念,我们通过下面的简单示例来了解一下它们的作用于区别. ...
- java中String new和直接赋值的区别
Java中String new和直接赋值的区别 对于字符串:其对象的引用都是存储在栈中的,如果是编译期已经创建好(直接用双引号定义的)的就存储在常量池中,如果是运行期(new出来的)才 ...
- 【Java学习笔记之二十九】Java中的equals和==的用法及区别
Java中的"equals"和"=="的用法及区别 在初学Java时,可能会经常碰到下面的代码: 1 String str1 = new String(&quo ...
- Java中print、printf、println的区别 详解
Java中print.printf.println的区别详解 printf主要是继承了C语言的printf的一些特性,可以进行格式化输出 print就是一般的标准输出,但是不换行 println和pr ...
- Java中方法重载和方法重写的区别
文章目录 1 Java中方法重载和方法重写的区别 1 Java中方法重载和方法重写的区别 主要区别如下: 方法重载: 在同一个类中 方法名相同 参数个数.顺序.类型不同 返回值类型.访问修饰符任意 方 ...
- Java中的LongAdder和AtomicLong有什么区别?
● Java中的LongAdder和AtomicLong有什么区别? 考点:JDK 参考回答: JDK1.8引入了LongAdder类.CAS机制就是,在一个死循环内,不断尝试修改目标值,直到修改成功 ...
- Java中 byte[]数组序列化和fastjson序列化区别
Java中 byte[]数组序列化和fastjson序列化区别 Java中,对于对象可以通过序列化成byte数组或者序列化成json形式,这里做下两者的对比. 首先看下实现方式: 1 byte数组序列 ...
- JAVA中的方法和构造方法有什么区别
JAVA中的方法和构造方法有什么区别 1.方法有返回类型,方法名小写,不能和类名相同:构造方法没有返回类型,void也不行,名与类名相同. 2.构造方法是初始化对象的重要途径,所以就算你给一个类没有定 ...
最新文章
- jquerymobile从index.html跳转到另外一个xxxx.html文件,js不执行的解决
- datagrid如何获取一行数据中的某个字段值_MySQL 如何查找删除重复行?
- 【实战 Ids4】║ 控制台密码模式搭配Ocelot网关
- haproxy acl访问限制IP
- linux 空信息,为什么recv()函数收到空消息?
- esxi update patch
- ceshi wenz
- 关系型数据库的一对一、一对多、多对一、多对多关系
- 高考为什么考计算机信息,信息技术是否应该进入高考?
- chloe.mysql_WPF权限控制——【3】数据库、自定义弹窗、表单验证
- BIM模型文件下载——江湖别墅Revit模型
- 一招教你不用任何软件就能知道谁动过你的电脑并做了哪些详细的操作,比查看Recent文件访问记录更厉害的方法开机自动运行PSR录制截取电脑操作
- 网站强制跳转到国家反诈中心如何解封
- Golang【sgg】
- idea中执行“npm”命令,提示‘npm‘ 不是内部或外部命令,也不是可运行的程序
- 问题(ArcGIS):去除栅格不需要的Value(背景值0)
- springboot 微信太阳码_springboot教务管理系统+微信小程序云开发
- zerotier使用教程_OPENWRT LEDE 配置ZeroTier网络教程
- 抖音取图表情包小程序源码+创作者入驻+流量主
- 计算机专业香港msc,香港大学计算机院面试 for MSc in Computer Science (19/20 Round)
热门文章
- 数据存储方式_视频监控系统的数据存储方式的概念及应用
- java8 Optional正确使用姿势
- python面向对象类_python面向对象-类和对象
- CTFHUB 《基础认证》:burp使用,basic请求了解
- spring html访问统计,spring-mvc访问本地html文件(示例代码)
- android键盘移动光标,在Android键盘上完成键
- mysql禁用历史命令_如何禁止mysql记录历史命令
- html div如何列对其,CSS:自适应N列布局如何解决两端对齐
- mysql实体监听器_GitHub - langjiangit/spring-boot-starter-mysql-binlog: mysql的binlog监听器
- opencv如何把一个矩阵不同列分离开_学习OPEN_CV