`

FutureTask实例

阅读更多
package com.zhoubo.concurrent.future;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * Preloader creates a FutureTask that describes the task of loading product information from a database 
 * and a thread in which the computation will be performed. 
 * When the program later needs the ProductInfo, it can call get, which returns the loaded data if it is ready, 
 * or waits for the load to complete if not.
 * @author Administrator
 *
 */
public class Preloader {
	//FutureTask implements the Runnable and Future Task
	private final FutureTask<ProductInfo> future = new FutureTask<ProductInfo>(
			new Callable<ProductInfo>() {
				public ProductInfo call() throws DataLoadException {
					return loadProductInfo();
				}
			});
	private final Thread thread = new Thread(future);

	/**
	 * It provides a start method to start the thread, 
	 * since it is inadvisable to start a thread from a constructor or static initializer
	 */
	public void start() {
		thread.start();
	}
	
	public ProductInfo loadProductInfo(){
		try{
			//使得加载数据延迟,让等待get的现象变得明显
			Thread.currentThread().sleep(2000);
		}catch (Exception e) {
			e.printStackTrace();
		}
		//int k=3/0;//make an exception
		return new ProductInfo("happy every day");
	}

	public ProductInfo get() throws DataLoadException, InterruptedException {
		try {
//			future.cancel(true);
			return future.get();
		} catch (ExecutionException e) {
			//异常处理
			Throwable cause = e.getCause();
			if (cause instanceof DataLoadException)
				throw (DataLoadException) cause;
			else
				throw launderThrowable(cause);
		}
	}
	
	public static RuntimeException launderThrowable(Throwable t) {
	    if (t instanceof RuntimeException)
	        return (RuntimeException) t;
	    else if (t instanceof Error)
	        throw (Error) t;
	    else
	        throw new IllegalStateException("Not unchecked", t);
	}
	
	public static void main(String ...args){
		Preloader loader = new Preloader();
		loader.start();
		try{
			System.out.println(loader.get());
		}catch (Exception e) {
			e.printStackTrace();
		}
	}

}

class ProductInfo {
	private String productName;
	
	public ProductInfo() {
		// TODO Auto-generated constructor stub
	}
	
	public ProductInfo(String productName) {
		this.productName = productName;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return productName;
	}

}

class DataLoadException extends Exception {

}
分享到:
评论

相关推荐

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

    当你有一个Callable任务并希望将其作为线程执行时,可以创建一个FutureTask实例,然后将这个实例传递给Executor。 下面简要说明它们之间的关系和用法: - Runnable通常用于简单的任务,不关心结果的返回。 - ...

    Java线程池FutureTask实现原理详解

    FutureTask实现原理通过submit方法的返回值,为一个Future,实际上这个Future为FutureTask实例,通过此实例,调用get方法,可以阻塞当前线程,直到任务运行完毕,返回结果。整个调用链条如下所示:worker thread -&gt; ...

    【Java】Callable创建线程用到的适配器模式(csdn)————程序.pdf

    2. 创建FutureTask实例:FutureTask是Java并发包(java.util.concurrent)中的一个类,它是一个可以被取消的任务,同时也是一个实现了Runnable接口的Future。FutureTask提供了对Callable结果的访问和管理,包括获取...

    FutureTask学习

    - `FutureTask(Runnable runnable, V result)`:用给定的`Runnable`实例和预期结果创建一个新的`FutureTask`。这个版本通常用于那些不返回结果的任务。 2. **主要方法**: - `void run()`:执行任务。当`Executor...

    java8源码-concurrency:java并发总结

    java8 源码 Java 并发多线程从简到全 ...实例,这个实例 outcome 成员变量用于存储线程的执行结果, state 成员变量用于记录线程的执行状态。 由于不知道什么时候线程执行完毕并返回结果,主线程只能主动轮询查看线程

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

    例如,对于`ExecutorService es`,执行`submit()`方法时,内部会将`Runnable`或`Callable`包装成`RunnableFuture`实例,如`FutureTask`。`ExecutorService`执行这个`RunnableFuture`,任务完成后,结果可通过`Future...

    简谈java并发FutureTask的实现

    在使用`FutureTask`时,我们通常会创建一个实例,然后将其提交给`ExecutorService`执行。例如,在给出的`FutureTaskTest`案例中,我们创建了一个`AccCallable`实例,它实现了`Callable`接口并返回两个整数的和。然后...

    java线程实例 各种小Demo

    3. 实现Callable接口与FutureTask:Callable接口的call()方法可以返回一个结果,FutureTask可以用于获取这个结果。这种方式适合需要返回值的多线程场景。 二、线程状态与控制 Java线程有五种状态:新建、可运行、...

    tiny-asyncload:动态代理+延迟加载+futureTask的一种应用思路

    当创建一个代理对象时,我们需要指定一个接口列表和一个InvocationHandler实例。InvocationHandler的`invoke()`方法会在代理对象调用接口方法时被触发,我们可以在这里进行额外的操作,比如日志记录、事务管理或者在...

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

    在示例代码中,我们首先使用Lambda表达式创建了一个Callable对象,然后将该实例包装成了一个FutureTask对象。主线程中当循环变量i等于20时,程序启动以FutureTask对象为target的线程。程序最后调用FutureTask对象的...

    线程实例(并发库引入到Java标准库 )

    有以下类的实例: ThreadPool ScheduledThread CyclicBarrier BlockingQueue CountDownLatch FutureTask CompletionService Semaphore

    java线程编程(概念+实例)

    3. 使用Callable和Future:适合需要返回结果的线程,创建Callable对象,通过FutureTask包装,再创建Thread。 以下是一个简单的Runnable接口示例: ```java class MyRunnable implements Runnable { public void ...

    Java分布式应用学习笔记05多线程下的并发同步器

    - **创建FutureTask**:然后,将`Callable`对象传递给`FutureTask`构造函数,从而创建一个`FutureTask`实例。 - **创建线程**:接下来,使用`FutureTask`实例创建一个新的线程。 - **执行任务**:启动线程,它会调用...

    基于Java Callable接口实现线程代码实例

    基于Java Callable接口实现线程代码实例 Java Callable接口简介 Java Callable接口是Java中的一种特殊接口,用于实现线程的返回值。该接口提供了一个call()方法,该方法可以返回一个值,用于获取线程执行的结果。 ...

    java 多线程实例

    - 实现`Callable`接口:适用于需要有返回结果的线程,可以抛出检查异常,通过`FutureTask`包装`Callable`并使用`ExecutorService`执行。 2. **线程的状态与生命周期** - 新建(New):线程被创建但未启动。 - 可...

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

    在这个例子中,我们创建了一个`ExecutorService`来执行任务,然后创建了一个`FutureTask`,将`Callable`实例作为参数传入。`ExecutorService`执行`FutureTask`,`call()`方法在新线程中运行,返回一个字符串。通过...

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

    这意味着你可以将一个`Runnable`或`Callable`实例包装成一个`FutureTask`,然后提交给线程池执行。`FutureTask`不仅提供了`Future`的所有功能,还能执行任务并管理其生命周期。 下面我们将详细探讨`FutureTask`的...

    多线程操作实例源码

    通过FutureTask包装Callable对象,可以将其转换为可由Thread执行的任务。这种方式适用于需要从线程获取返回值的情况。 在多线程操作中,通常会涉及到以下几个关键概念: - **线程同步**:当多个线程访问共享资源时...

    java中的多线程实例详解(自己去运行看结果)

    需要通过`FutureTask`包装`Callable`,再创建`Thread`。 线程状态转换是理解多线程的关键,包括新建、就绪、运行、阻塞和终止等状态。Java提供了一些线程控制方法,如`sleep()`使线程休眠,`join()`等待线程结束,`...

    java面试精华14

    - 在本例中,首先创建了一个`FutureTask`实例,并通过`executor.submit()`方法将其提交给线程池执行。 #### 四、总结 通过上述分析,我们可以看出,在Java中,使用`Callable`接口和`Future`或`FutureTask`可以...

Global site tag (gtag.js) - Google Analytics