【Java高并发学习】Future模式

最新推荐文章于 2025-06-05 09:16:37 发布

原创最新推荐文章于 2025-06-05 09:16:37 发布 · 466 阅读

1 ·

CC 4.0 BY-SA版权

Java高并发专栏收录该内容

13 篇文章

订阅专栏

本文介绍了Future模式的核心思想及其在异步处理中的应用。通过一个简单的示例展示了如何使用Future模式来提高程序的响应速度，并探讨了Java标准库中Future模式的具体实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Future模式

1.Future模式

核心思想：异步调用
当调用某一个函数时，如果该函数执行时间很长，但又不需要及时获取结果。可以让被调用者立即返回，让它后台继续处理，此时调用者可以先处理其他任务，等到需要时再尝试获取需要的数据。
利用等待时间，取处理其他任务，从而提高系统的响应速度。

以下为Future模式结构图。

2.Future模式简单实现例子

/**
 * 希望获取的数据
 * @author wsz
 * @date 2018年1月3日
 */
public interface Data {
	String getResult();
}

/**
 * 真实数据RealData的代理，封装了获取RealData的等待过程 
 * @author wsz
 * @date 2018年1月3日
 */
public class FutureData implements Data{

	protected RealData realdata = null;   //进行包装RealData
	
	protected boolean isReady = false;
	
	public synchronized void setRealData(RealData realdata) {
		if(isReady) {
			return;
		}
		this.realdata = realdata;
		isReady = true;
		notifyAll();   //RealData已经注入，通知getResult()
	}
	
	@Override
	public synchronized String getResult() {
		while(!isReady) {
			try {
				wait();			//一直等待，直到RealData被注入并唤醒
			}catch(InterruptedException e) {
				e.printStackTrace();
			}
		}
		return realdata.result;  //返回真正的RealData
	}
}

import java.util.concurrent.Callable;

public class RealData implements Callable<String>{

	private String para;
	
	public RealData(String para) {
		super();
		this.para = para;
	}

	@Override
	public String call() throws Exception {
		StringBuffer sb = new StringBuffer();
		for(int i =0 ;i <10; i++) {
			sb.append(para);
			Thread.sleep(100);
		}
		return sb.toString();
	}

}

public class Client {

	public Data request(final String queryStr) {
		final FutureData future = new FutureData();
		new Thread() {	//RealData的构造很慢，在单独的线程中进行
			public void run() {
				RealData realdata = new RealData(queryStr);
				future.setRealData(realdata);
			}
		}.start();;
		return future;
	}
	
	public static void main(String[] args) {
		Client client = new Client();
		Data data = client.request("test");//这里会立即返回，因为得到的是FutureData而不是RealData
		System.out.println("请求完毕");
//		System.out.println(data.getResult());构造较慢，有明显的延迟
		try {
			Thread.sleep(2000);  //模拟其他业务逻辑的处理过程，该过程中RealData被创建
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(data.getResult());//真实数据
	}
}

3.JDK中的Future模式

import java.util.concurrent.Callable;
/**
 * 真实数据，实现Callable接口
 * @author wsz
 * @date 2018年1月3日
 */
public class RealData implements Callable<String>{

	private String para;
	
	public RealData(String para) {
		super();
		this.para = para;
	}

	@Override
	public String call() throws Exception {
		StringBuffer sb = new StringBuffer();
		for(int i =0 ;i <10; i++) {
			sb.append(para);
			Thread.sleep(100);
		}
		return sb.toString();
	}
}

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
/**
 * @author wsz
 * @date 2018年1月3日
 */
public class FutureMain {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//构造FutureTask
		FutureTask<String> future = new FutureTask<String>(new RealData("test"));
		ExecutorService executor = Executors.newFixedThreadPool(1);
		//执行FutureTask，相当于client.request("test")
		//开启线程进行RealData的call
		executor.submit(future);
		
		System.out.println("请求完毕");
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(future.get());
	}
}