FutureTask类是Future 的一个实现,并实现了Runnable,所以可通过Excutor(线程池) 来执行,也可传递给Thread对象执行。今天我们通过实例来学习一下FutureTask的用法。

多线程中FutureTask的使用

一、FutureTask的简单使用

package com.huhx.chenhui.nio;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask; public class CallableThreadTest implements Callable<Integer> {
public static void main(String[] args) {
CallableThreadTest threadTest = new CallableThreadTest();
FutureTask<Integer> future = new FutureTask<>(threadTest);
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " 的循环变更i的值" + i);
if (i == 2) {
new Thread(future, "有返回的线程").start();
}
}
try {
System.out.println("子线程的返回值:" + future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
} @Override
public Integer call() throws Exception {
int i = 0;
for (; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "" + i);
}
return i;
}
}

运行结果如下:

main 的循环变更i的值0
main 的循环变更i的值1
main 的循环变更i的值2
main 的循环变更i的值3
main 的循环变更i的值4
main 的循环变更i的值5
main 的循环变更i的值6
main 的循环变更i的值7
main 的循环变更i的值8
main 的循环变更i的值9
有返回的线程0
有返回的线程1
有返回的线程2
有返回的线程3
有返回的线程4
有返回的线程5
有返回的线程6
有返回的线程7
有返回的线程8
有返回的线程9
子线程的返回值:

二、 FutureTask的get方法的超时测试

package com.linux.huhx.thread;

import java.util.concurrent.*;

public class FutureTest {
public static void main(String[] args) throws TimeoutException {
FutureTask<String> future = new FutureTask<String>(new Task());
new Thread(future).start();
try {
System.out.println(future.get(4L, TimeUnit.SECONDS));
System.out.println("main thread");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
} static class Task implements Callable<String> {
@Override
public String call() throws Exception {
System.out.println("begin: " + Thread.currentThread().getName() + ", " + System.currentTimeMillis());
TimeUnit.SECONDS.sleep(5);
return "hello";
}
}
}

运行的效果如下:

aaarticlea/gif;base64,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" alt="" />

官方文档对于这个方法的说明如下:

Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available. 

FutureTask的原理分析

FutureTask类的继承结构如下:

public class FutureTask<V> implements RunnableFuture<V>
public interface RunnableFuture<V> extends Runnable, Future<V>

FutureTask重写了run()方法,代码如下:

public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call(); // 调用Callable类中的call方法
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}

FutureTask的get方法,得到线程执行返回的结果。

Object x = outcome;
if (s == NORMAL)
return (V)x;

友情链接

java高级---->Thread之FutureTask的使用的更多相关文章

  1. java高级---->Thread之ScheduledExecutorService的使用

    ScheduledExecutorService的主要作用就是可以将定时任务与线程池功能结合使用.今天我们来学习一下ScheduledExecutorService的用法.我们都太渺小了,那么容易便湮 ...

  2. java高级---->Thread之ExecutorService的使用

    今天我们通过实例来学习一下ExecutorService的用法.我徒然学会了抗拒热闹,却还来不及透悟真正的冷清. ExecutorService的简单实例 一.ExecutorService的简单使用 ...

  3. java高级---->Thread之Phaser的使用

    Phaser提供了动态增parties计数,这点比CyclicBarrier类操作parties更加方便.它是jdk1.7新增的类,今天我们就来学习一下它的用法.尘埃落定之后,回忆别来挑拨. Phas ...

  4. java高级---->Thread之CompletionService的使用

    CompletionService的功能是以异步的方式一边生产新的任务,一边处理已完成任务的结果,这样可以将执行任务与处理任务分离开来进行处理.今天我们通过实例来学习一下CompletionServi ...

  5. java高级---->Thread之CyclicBarrier的使用

    CyclicBarrier是一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point).今天我们就学习一下CyclicBarrier的用法. Cycl ...

  6. java高级---->Thread之BlockingQueue的使用

    今天我们通过实例来学习一下BlockingQueue的用法.梦想,可以天花乱坠,理想,是我们一步一个脚印踩出来的坎坷道路. BlockingQueue的实例 官方文档上的对于BlockingQueue ...

  7. java高级---->Thread之Exchanger的使用

    Exchanger可以在两个线程之间交换数据,只能是2个线程,他不支持更多的线程之间互换数据.今天我们就通过实例来学习一下Exchanger的用法. Exchanger的简单实例 Exchanger是 ...

  8. java高级---->Thread之Condition的使用

    Condition 将 Object 监视器方法(wait.notify 和 notifyAll)分解成截然不同的对象,以便通过将这些对象与任意 Lock 实现组合使用,为每个对象提供多个等待 set ...

  9. java高级---->Thread之CountDownLatch的使用

    CountDownLatch是JDK 5+里面闭锁的一个实现,允许一个或者多个线程等待某个事件的发生.今天我们通过一些实例来学习一下它的用法. CountDownLatch的简单使用 CountDow ...

随机推荐

  1. USB 之传输编码格式 NRZI 介绍

    记录NRZI (Non-Return-to-Zero Inerted code) 非归零翻转编码,之前,我先稍微记录一下他的前身. RZ 编码(Return- to - zero coding) RZ ...

  2. Energy Modes能量管理模式

    1  EM0 运行模式 默认模式; 2  EM1 休眠模式 休眠模式 主处理器停止,片上系统模块运行; 3  EM2 深度休眠 只有异步或低频外设运行; 4  EM3 停止模式 与EM2相比,低频晶振 ...

  3. NTP原理

    ntp原理与设置 原创                     2016年09月17日 15:28:16                 标签: ntp / 原理 / 设置 / linux / 时钟同 ...

  4. unarchive模块

    unarchive模块 用于解压文件,模块包含如下选项: copy:在解压文件之前,是否先将文件复制到远程主机,默认为yes.若为no,则要求目标主机上压缩包必须存在. creates:指定一个文件名 ...

  5. BeamNG.drive物理引擎评鉴

    BeamNG.drive是一款由BeamNG公司开发并于2013年首次发布的软体物理模拟游戏.作为模拟游戏,特别是物理模拟的粉丝,我早早就开始使用BeamNG.drive.我立即对崩溃的准确性和细节印 ...

  6. HBase二级索引方案总结

    转自:http://blog.sina.com.cn/s/blog_4a1f59bf01018apd.html 附hbase如何创建二级索引以及创建二级索引实例:http://www.aboutyun ...

  7. UIView的几个枚举定义

    UIView是iOS开发最主要的视图,非常多控件都是继承它,掌握当中的几个基本枚举定义,有利益理解视图的载入和參数差别. 一.UIViewAnimationCurve UIView的基本动画变化规律 ...

  8. windows 下安装perl Tk 模块

    首先,安装activeperl ,安装过程中勾选自动添加PATH环境变量,这样安装后就不需要自己手动修改PATH环境变量: 通过cmd 调出命令行窗口,输入ppm ,然后回车,就开启了perl 的包管 ...

  9. 从VirtualBox虚拟主机访问NAT客户机的方法

    转自:http://www.jb51.net/os/other/352995.html VirtualBox对虚拟机支持几种不同的网络方式,其中一种是NAT网络.当虚拟机启用NAT后,VirtualB ...

  10. Linux新手要了解的十个知识点

    Linux对于有的新手来说,感觉无从下手,或者不知道从哪儿学起?怎么学?针对这些问题,我给大家说说新手学习Linux需要了解的十个知识点. 注意大小写 Linux是大小写敏感的系统,举个例子,Mozi ...