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. [DNS]部署局域网DNS服务器

    This is a step by step tutorial on how to install and configure DNS server for your LAN using bind9. ...

  2. Golang 类型转换整理

    1.整形到字符串: var i int = 1 var s string s = strconv.Itoa(i) 或者 s = FormatInt(int64(i), 10) 2.字符串到整形 var ...

  3. FTP内容

    1.1.1 作业FTP部署. FTP工具或者浏览器默认使用的都是PASV模式连接FTP服务器 1.先检查有没有安装   rpm -q vsftpd 如果没有安装   yum install vsftp ...

  4. 当数据库的字段为date类型时候

    当数据库的字段为date类型时候: //--------------------------------------------------数据库设计------------------------- ...

  5. ggplot2——简介

    ggplot2是R语言最为强大的作图软件包,强于其自成一派的数据可视化理念.当熟悉了ggplot2的基本套路后,数据可视化工作将变得非常轻松而有条理. 本文主要对ggplot2的可视化理念及开发套路做 ...

  6. 如何打印Qt中的枚举所对应的字符串

    比如,想获得socket的状态枚举文字, 代码如下: QMetaObject mo=QAbstractSocket::staticMetaObject; int index=mo.indexOfEnu ...

  7. CentOS 7修改MySQL 5.6字符集为UTF-8

    MySQL编码原因会导致数据库出现中文乱码 解决办法: 修改MySQL数据库字符编码为UTF-8,UTF-8包含全世界所有国家需要用到的字符,是国际编码. 具体操作: 1.进入MySQL控制台 mys ...

  8. android 自定义照相机Camera黑屏 (转至 http://blog.csdn.net/chuchu521/article/details/8089058)

    对于一些手机,像HTC,当自定义Camera时,调用Camera.Parameters的 parameters.setPreviewSize(width, height)方法时,如果width和hei ...

  9. Making the iPhone vibrate (iPhone 振动)

    from: http://stackoverflow.com/a/4725039 There are two seemingly similar functions that take a param ...

  10. Spring-Resource接口

    4.1.1 概述 在日常程序开发中,处理外部资源是很繁琐的事情,我们可能需要处理URL资源.File资源资源.ClassPath相关资源.服务器相关资源(JBoss AS 5.x上的VFS资源)等等很 ...