Java多线程编程中Future模式的详解

刺骨的言语ヽ痛彻心扉 2022-08-21 12:44 117阅读 0赞

Java多线程[编程][Link 1]中，常用的多线程设计模式包括：Future模式、Master-Worker模式、Guarded Suspeionsion模式、不变模式和生产者-消费者模式等。这篇文章主要讲述Future模式，关于其他多线程设计模式的地址如下：  
关于其他多线程设计模式的地址如下：  
关于Master-Worker模式的详解： [Java][]多线程编程中Master-Worker模式的详解  
关于Guarded Suspeionsion模式的详解： Java多线程编程中Guarded Suspeionsion模式的详解  
关于不变模式的详解： Java多线程编程中不变模式的详解  
关于生产者-消费者模式的详解：生产者-消费者模式Java详解

# 1. Future模式核心思想 #

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

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

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

![\\][20141113091348310.png]

# 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. 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());
    	}
    }

[Link 1]: http://www.2cto.com/kf
[Java]: http://www.2cto.com/kf/ware/Java/
[20141113091348310.png]: http://www.2cto.com/uploadfile/Collfiles/20141113/20141113091348310.png