`

Runnable、Callable、Executor、Future、FutureTask关系解读

阅读更多
转自:http://blog.csdn.net/zhangzhaokun/article/details/6615454

在再度温习Java5的并发编程的知识点时发现,首要的就是把Runnable、Callable、Executor、Future等的关系搞明白,遂有了下述小测试程序,通过这个例子上述三者的关系就一目了然了。

在java5以后,一个可以调度执行的线程单元可以有三种方式定义:

Thread、Runnable、Callable,其中Runnable实现的是void run()方法,Callable实现的是 V call()方法,并且可以返回执行结果,其中Runnable可以提交给Thread来包装下,直接启动一个线程来执行,而Callable则一般都是提交给ExecuteService来执行。

简单来说,Executor就是Runnable和Callable的调度容器,Future就是对于具体的调度任务的执行结果进行查看,最为关键的是Future可以检查对应的任务是否已经完成,也可以阻塞在get方法上一直等待任务返回结果。Runnable和Callable的差别就是Runnable是没有结果可以返回的,就算是通过Future也看不到任务调度的结果的。

/** 
 * 通过简单的测试程序来试验Runnable、Callable通过Executor来调度的时候与Future的关系 
 */  
package com.hadoop.thread;  
  
import java.util.concurrent.Callable;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.Future;  
  
public class RunnableAndCallable2Future {  
  
    public static void main(String[] args) {  
  
        // 创建一个执行任务的服务  
        ExecutorService executor = Executors.newFixedThreadPool(3);  
        try {  
            //1.Runnable通过Future返回结果为空  
            //创建一个Runnable,来调度,等待任务执行完毕,取得返回结果  
            Future<?> runnable1 = executor.submit(new Runnable() {  
                @Override  
                public void run() {  
                    System.out.println("runnable1 running.");  
                }  
            });  
            System.out.println("Runnable1:" + runnable1.get());  
  
            // 2.Callable通过Future能返回结果  
            //提交并执行任务,任务启动时返回了一个 Future对象,  
            // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作  
            Future<String> future1 = executor.submit(new Callable<String>() {  
                @Override  
                public String call() throws Exception {  
                    // TODO Auto-generated method stub  
                    return "result=task1";  
                }  
            });  
            // 获得任务的结果,如果调用get方法,当前线程会等待任务执行完毕后才往下执行  
            System.out.println("task1: " + future1.get());  
  
            //3. 对Callable调用cancel可以对对该任务进行中断  
            //提交并执行任务,任务启动时返回了一个 Future对象,  
            // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作  
            Future<String> future2 = executor.submit(new Callable<String>() {  
                @Override  
                public String call() throws Exception {               
                    try {  
                        while (true) {  
                            System.out.println("task2 running.");  
                            Thread.sleep(50);  
                        }  
                    } catch (InterruptedException e) {  
                        System.out.println("Interrupted task2.");  
                    }  
                    return "task2=false";  
                }  
            });  
              
            // 等待5秒后,再停止第二个任务。因为第二个任务进行的是无限循环  
            Thread.sleep(10);  
            System.out.println("task2 cancel: " + future2.cancel(true));  
  
            // 4.用Callable时抛出异常则Future什么也取不到了  
            // 获取第三个任务的输出,因为执行第三个任务会引起异常  
            // 所以下面的语句将引起异常的抛出  
            Future<String> future3 = executor.submit(new Callable<String>() {  
  
                @Override  
                public String call() throws Exception {  
                    throw new Exception("task3 throw exception!");  
                }  
  
            });  
            System.out.println("task3: " + future3.get());  
        } catch (Exception e) {  
            System.out.println(e.toString());  
        }  
        // 停止任务执行服务  
        executor.shutdownNow();  
    }  
}  

执行结果如下:

runnable1 running. 
Runnable1:null 
task1: result=task1 
task2 running. 
task2 cancel: true 
Interrupted task2. 
java.util.concurrent.ExecutionException: java.lang.Exception: Bad flag value! 
FutureTask则是一个RunnableFuture<V>,即实现了Runnbale又实现了Futrue<V>这两个接口,另外它还可以包装Runnable和Callable<V>,所以一般来讲是一个符合体了,它可以通过Thread包装来直接执行,也可以提交给ExecuteService来执行,并且还可以通过v get()返回执行结果,在线程体没有执行完成的时候,主线程一直阻塞等待,执行完则直接返回结果。

public class FutureTaskTest {  
  
    /** 
     * @param args 
     */  
    public static void main(String[] args) {  
        Callable<String> task = new Callable<String>() {  
            public String call() {  
                System.out.println("Sleep start.");  
                try {  
                    Thread.sleep(1000 * 10);  
                } catch (InterruptedException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
                System.out.println("Sleep end.");  
                return "time=" + System.currentTimeMillis();  
            }  
        };  
          
        //直接使用Thread的方式执行  
        FutureTask<String> ft = new FutureTask<String>(task);  
        Thread t = new Thread(ft);  
        t.start();  
        try {  
            System.out.println("waiting execute result");  
            System.out.println("result = " + ft.get());  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (ExecutionException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
          
        //使用Executors来执行  
        System.out.println("=========");  
        FutureTask<String> ft2 = new FutureTask<String>(task);  
        Executors.newSingleThreadExecutor().submit(ft2);  
        try {  
            System.out.println("waiting execute result");  
            System.out.println("result = " + ft2.get());  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (ExecutionException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
          
    }  
}  

执行结果如下:

waiting execute result 
Sleep start. 
Sleep end. 
result = time=1370844662537 
========= 
waiting execute result 
Sleep start. 
Sleep end. 
result = time=1370844672542 
分享到:
评论
1 楼 txxxs 2016-04-09  
good,bucuo

相关推荐

    Java中的Runnable,Callable,Future,FutureTask的比较

    Java中的Runnable、Callable、Future和FutureTask是Java多线程编程中的核心概念,它们各自扮演着不同的角色,共同协作以实现并发任务的管理和执行。 1. **Runnable**: Runnable是最基本的多线程接口,它只有一个`...

    Java使用Callable和Future创建线程操作示例

    "Java使用Callable和Future创建线程操作示例" Java使用Callable和Future创建线程操作示例主要介绍了Java使用Callable和Future创建线程操作,结合实例形式分析了java使用Callable接口和Future类创建线程的相关操作...

    Android(Java)之多线程结果返回——Future 、FutureTask、Callable、Runnable

    4. `FutureTask`: `FutureTask`结合了`Runnable`和`Future`的功能,它可以包装一个`Callable`对象,并作为`Runnable`提交给`Executor`,同时它也是一个`Future`,可以用来获取计算结果。创建`FutureTask`的示例: `...

    Java中Future、FutureTask原理以及与线程池的搭配使用

    `Future`接口提供了对异步计算结果的访问和控制,而`FutureTask`是`Future`的一个具体实现,它还同时实现了`Runnable`接口,因此可以直接提交给`Executor`执行。 `Future`接口提供了以下方法: 1. `boolean cancel...

    FutureTask学习

    `FutureTask`作为`Runnable`和`Callable`的桥梁,允许我们将一个`Callable`任务提交给`Executor`执行,并在后续代码中通过`FutureTask`的API查询任务状态,获取结果或取消任务。下面将详细介绍`FutureTask`的主要...

    Java FutureTask类使用案例解析

    它实现了Runnable和Future接口,既可以作为一个Runnable对象提交给Executor执行,也可以作为一个Future对象获取计算结果。 FutureTask类的使用案例主要有两种,一种是使用Callable对象,另一种是使用Runnable对象。...

    JAVA中Callable的使用

    `FutureTask`是`Future`的一个具体实现,它同时也是一个`Runnable`,可以直接提交给ExecutorService。`FutureTask`的构造函数接受一个Callable对象,当任务执行完成后,可以通过`FutureTask`的`get()`方法获取结果。...

    java多线程返回值使用示例(callable与futuretask)

    FutureTask&lt;String&gt; future = new FutureTask(new Callable() { @Override public String call() { try { Thread.sleep(10000); } catch (InterruptedException e) { e.printStackTrace(); } return "11111...

    Java多线程实现的四种方式

    在Java中,实现多线程有四种主要方法:继承Thread类、实现Runnable接口、使用ExecutorService和使用Callable与Future。下面将详细探讨这四种方式。 1. 继承Thread类 在Java中,我们可以直接继承Thread类并重写其run...

    java面试精华14

    本文将深入探讨如何利用Java提供的`Runnable`与`Callable`接口配合`Future`或`FutureTask`来实现这一功能。 #### 一、基础知识回顾 在开始之前,我们先简要回顾一下`Runnable`和`Callable`这两个接口的基本概念: ...

    java多线程编程同步器Future和FutureTask解析及代码示例

    总结来说,`Future` 是一个接口,用于管理异步任务的结果和状态,而`FutureTask`是一个具体的实现,它同时实现了`Runnable`和`Future`接口,可以直接提交给`ExecutorService`执行。在多线程编程中,正确地使用`...

    Executor框架使用详解

    `FutureTask`类实现了`Future`和`Runnable`,可以用来包装`Callable`任务并提交给`ExecutorService`。 标签中提到的“源码”意味着深入理解Executor框架的实现原理是重要的。例如,理解`ThreadPoolExecutor`如何...

    线程池之Executor框架.docx

    `FutureTask`是`Future`的一个实现,它同时实现了`Runnable`接口,可以直接被Executor执行。 2. **Executor框架的工作流程** - 主线程创建任务,通常是实现`Runnable`或`Callable`的实例。 - 创建`...

    四种方式实现线程

    // 提交Callable任务,返回Future executor.shutdown(); // 关闭线程池 ``` ExecutorService提供了线程池管理,可以控制并发数量,优化系统资源利用率。 以上四种方式各有优缺点。Thread类适合简单的线程需求,...

    Java多线程之异步Future机制的原理和实现共5页.p

    1. **使用FutureTask**:FutureTask是一个实现了RunnableFuture接口的类,它既可以作为Runnable被Executor执行,又可以作为Future获取结果。你可以直接创建一个FutureTask,传入Callable任务,然后提交给...

    31 凭票取餐—Future模式详解.pdf

    然后,将Callable对象包装成一个FutureTask,FutureTask同时实现了Runnable接口,因此可以被线程执行。 2. Future的使用 示例代码中,创建了一个`FutureTask&lt;String&gt; cookTask`,它的构造函数接收一个Callable对象...

    java实现线程的异步

    FutureTask 是一个实现了 Runnable 和 Future 的类,可以将 Callable 包装成 Runnable,并返回计算结果: ```java Callable&lt;Integer&gt; callable = () -&gt; { // 执行计算任务,返回结果 return 42; }; FutureTask...

    顶层接口Executors详解

    工作单元包括Runnable和Callable,而执行机制由Executor框架提供。 2. 框架结构 Executor框架采用的是两级调度模型。在HotSpot VM的线程模型中,Java线程被一对一映射为本地操作系统线程。Java线程启动时会创建一...

    有返回值的线程

    除了`Callable`和`Future`,还可以使用`Runnable`配合`ExecutorService`和`Future`来实现有返回值的线程。首先创建一个实现了`Runnable`的类,然后在内部创建一个`Future`对象,通过`ExecutorService`提交任务并获取...

    多线程执行完后主程序再执行(包括需要子线程返回结果)

    `FutureTask`是`Future`的一个实现,同时它也是`Runnable`和`Future`的组合。这意味着你可以将一个`Runnable`或`Callable`实例包装成一个`FutureTask`,然后提交给线程池执行。`FutureTask`不仅提供了`Future`的所有...

Global site tag (gtag.js) - Google Analytics