Java源码之Future

Java源码之Future

 

 

转载请注明出处:http://blog.csdn.net/itismelzp/article/details/77761112

 

一、Future概述

 

Future用于表示异步计算模型的结果。它的方法包括:检测是否计算完成、等待计算完成、返回计算结果。

如果计算结束,使用get()函数可以返回结果,如果计算正在进行,get()函数将阻塞以等待计算结果。

cancel()方法用于取消计算,并返回是否取消成功。isCanceled()返回是否取消成功,一但计算已结束,将无法再取消。

如果想使用一种可取消的计算,并且不提供一个可用的结果。可用声明Future<?>,并返回null。

 

下面是Future的源码:

package java.util.concurrent;

/**
 * @see FutureTask
 * @see Executor
 * @since 1.5
 * @author Doug Lea
 * @param <V> The result type returned by this Future's {@code get} method
 */
public interface Future<V> {

    /**
     * 尝试取消任务
     * 
     * mayInterruptIfRunning为true时尝试取消当前任务parameter determines
     * 并返回是否取消成功结果
     */
    boolean cancel(boolean mayInterruptIfRunning);

    /**
     * 返回任务是否在完成前被取消.
     */
    boolean isCancelled();

    /**
     * 返回任务是否完成.
     *
     * 任务被中断/取消/正常完成/异常都会返回true.
     *
     */
    boolean isDone();

    /**
     * 等待并返回计算结果
     *
     * 如果结果被取消抛CancellationException异常
     * 如果等待被中断抛InterruptedException异常
     * 如果当前线程被中断抛ExecutionException异常
     * 
     */
    V get() throws InterruptedException, ExecutionException;

    /**
     * 设置等待时间,等待并返回计算结果
     * 
     * 如果结果被取消抛CancellationException异常
     * 如果等待被中断抛InterruptedException异常
     * 如果当前线程被中断抛ExecutionException异常
     * 
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

 

 

 

 

 

二、Future初探

 

在并发编程时,一般使用runnable,然后扔给线程池完事,这种情况下不需要线程的结果,所以run的返回值是void类型。 

如果是一个多线程协作程序,比如线程A需要线程B的结果,就需要用callable接口了。 callable用法和runnable一样,只不过调用的是call方法,该方法有一个泛型返回值类型,你可以任意指定。 

线程是属于异步计算模型,所以你不可能直接从别的线程中得到函数返回值。 这时候,Future就出场了。Futrue可以监视目标线程调用call的情况,当你调用Future的get()方法以获得结果时,当前线程就开始阻塞,直接call方法结束返回结果。 

下面三段简单的代码可以很简明的揭示这个意思:

 

public class RunnableTest {

	public static class Task implements Runnable {

		@Override
		public void run() {
			System.out.println("thread runing...");
		}

	}

	public static void main(String[] args) {

		ExecutorService es = Executors.newCachedThreadPool();
		for (int i = 0; i < 10; i++) {
			es.submit(new Task());
		}
	}

}

runnable接口实现的没有返回值的并发编程。

 

public class FutureTest {

	public static class Task implements Callable<String> {
		@Override
		public String call() throws Exception {
			System.out.println("do something ...");
			return "result";
		}
	}

	public static void main(String[] args) throws Exception {
		ExecutorService es = Executors.newCachedThreadPool();
		List<Future<String>> results = new ArrayList<>();

		for (int i = 0; i < 10; i++) {
			results.add(es.submit(new Task()));
		}
	}
}

callable实现的存在返回值的并发编程。(call的返回值String受泛型的影响)

 

 

public class FutureTest {

	public static class Task implements Callable<String> {
		@Override
		public String call() throws Exception {
			System.out.println("do something ...");
			return "result";
		}
	}

	public static void main(String[] args) throws Exception {
		ExecutorService es = Executors.newCachedThreadPool();
		List<Future<String>> results = new ArrayList<>();
		
		for(int i = 0; i < 10; i++) {
			results.add(es.submit(new Task()));
		}
		
		// 获取执行结果
		for(Future<String> f : results) {
			System.out.println(f.get());
		}
	}
}

运行结果:

 

 

 

三、Future实现

 

3.1 Future模式核心思想


Future模式的核心在于:去除了主函数的等待时间,并使得原本需要等待的时间段可以用于处理其他业务逻辑(根据《Java程序性能优化》)。

Future模式有点类似于商品订单。在网上购物时,提交订单后,在收货的这段时间里无需一直在家里等候,可以先干别的事情。类推到程序设计中时,当提交请求时,期望得到答复时,如果这个答复可能很慢。传统的时一直等待到这个答复收到时再去做别的事情,但如果利用Future设计模式就无需等待答复的到来,在等待答复的过程中可以干其他事情。

例如如下的请求调用过程时序图。当call请求发出时,需要很长的时间才能返回。左边的图需要一直等待,等返回数据后才能继续其他操作;而右边的Future模式的图中客户端则无需等到可以做其他的事情。服务器段接收到请求后立即返回结果给客户端,这个结果并不是真实的结果(是虚拟的结果),也就是先获得一个假数据,然后执行其他操作。

 

 

 

 


 

3.2  Future模式Java实现

 

Client的实现,Client主要完成两个功能:

 

1)返回一个FutureData;

2)开启一个线程用于构造RealData。

 

public class Client {
	public Data request(final String string) {
		final FutureData futureData = new FutureData();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				//RealData的构建很慢,所以放在单独的线程中运行
				RealData realData = new RealData(string);
				futureData.setRealData(realData);
			}
		}).start();
		
		return futureData; //先直接返回FutureData
	}
}

 

Data的实现
无论是FutureData还是RealData都实现该接口。

public interface Data {
	String getResult() throws InterruptedException;
}

 

FutureData的实现
FutureData是Future模式的关键,它实际上是真实数据RealData的代理,封装了获取RealData的等待过程。

//FutureData是Future模式的关键,它实际上是真实数据RealData的代理,封装了获取RealData的等待过程
public class FutureData implements Data {
	RealData realData = null; //FutureData是RealData的封装
	boolean isReady = false;  //是否已经准备好
	
	public synchronized void setRealData(RealData realData) {
		if(isReady)
			return;
		this.realData = realData;
		isReady = true;
		notifyAll(); //RealData已经被注入到FutureData中了,通知getResult()方法
	}

	@Override
	public synchronized String getResult() throws InterruptedException {
		if(!isReady) {
			wait(); //一直等到RealData注入到FutureData中
		}
		return realData.getResult(); 
	}
}


RealData的实现
RealData是最终需要使用的数据,它的构造函数很慢。

public class RealData implements Data {
	protected String data;

	public RealData(String data) {
		//利用sleep方法来表示RealData构造过程是非常缓慢的
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.data = data;
	}

	@Override
	public String getResult() {
		return data;
	}
}

 

 

 

测试运行
主函数主要负责调用Client发起请求,并使用返回的数据。

 

public class Application {
	public static void main(String[] args) throws InterruptedException {
		Client client = new Client();
		//这里会立即返回,因为获取的是FutureData,而非RealData
		Data data = client.request("name");
		//这里可以用一个sleep代替对其他业务逻辑的处理
		//在处理这些业务逻辑过程中,RealData也正在创建,从而充分了利用等待时间
		Thread.sleep(2000);
		//使用真实数据
		System.out.println("数据="+data.getResult());
	}
}

 

 

 

 

3.3 Future模式的JDK内置实现


由于Future是非常常用的多线程设计模式,因此在JDK中内置了Future模式的实现。这些类在java.util.concurrent包里面。其中最为重要的是FutureTask类,它实现了Runnable接口,作为单独的线程运行。在其run()方法中,通过Sync内部类调用Callable接口,并维护Callable接口的返回对象。当使用FutureTask.get()方法时,将返回Callable接口的返回对象。同样,针对上述的实例,如果使用JDK自带的实现,则需要作如下调整。

首先,Data接口和FutureData就不需要了,JDK帮我们实现了。

其次,RealData改为这样:

 

import java.util.concurrent.Callable;

public class RealData implements Callable {
	protected String data;

	public RealData(String data) {
		this.data = data;
	}

	@Override
	public String call() throws Exception {
		//利用sleep方法来表示真是业务是非常缓慢的
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return data;
	}
}


最后,在测试运行时,这样调用:

 

 

 

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class Application {
	public static void main(String[] args) throws Exception {
		FutureTask futureTask = 
				new FutureTask(new RealData("name"));
		ExecutorService executor = 
				Executors.newFixedThreadPool(1); //使用线程池
		//执行FutureTask,相当于上例中的client.request("name")发送请求
		executor.submit(futureTask);
		//这里可以用一个sleep代替对其他业务逻辑的处理
		//在处理这些业务逻辑过程中,RealData也正在创建,从而充分了利用等待时间
		Thread.sleep(2000);
		//使用真实数据
		//如果call()没有执行完成依然会等待
		System.out.println("数据=" + futureTask.get());
	}
}

 

 

 

 

 

 

参考:

[1] http://www.oschina.net/question/54100_83333

[2] http://blog.csdn.net/ghsau/article/details/7451464

[3] https://www.2cto.com/kf/201411/351903.html

 

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值