Java多线程编程 —— Future模式

Java › Concurrency

关于多线程的设计模式，主要包括：Future模式、Master-Worker模式、Guarded Suspeionsion模式、不变模式和生产者-消费者模式等。

近期由于需求，用到了Future设计模式，说来惭愧，对于设计模式偶尔用过，但没有系统化的归纳和总结。接下来一段时间，希望能够完善这部分的知识空白吧。

Future模式的核心思想

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

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

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

future_call.png

Future模式的Java实现

Client实现

Client主要完成的功能包括：

  1. 返回一个FutureData；
  2. 开启一个线程用于构造RealData。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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都实现该接口。

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

FutureData实现

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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是最终需要使用的数据，主要体现了被调用的线程处理任务的过程，它的构造函数处理很慢。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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发起请求，并使用返回的数据。

1
2
3
4
5
6
7
8
9
10
11
12
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());  
    }  
}

Future模式的JDK内置实现

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

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

其次，RealData改为这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.concurrent.Callable;  
  
public class RealData implements Callable<String> {  
    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;  
    }  
}

测试运行：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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<String> futureTask =   
                new FutureTask<String>(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());  
    }  
}

总结

  • Runnable：在并发编程时，一般使用runnable，然后扔给线程池完事，这种情况下不需要线程的结果，所以run的返回值是void类型。
  • Callable：如果是一个多线程协作程序，比如斐波那契数列，1，1，2，3，5，8…使用多线程来计算。但后者需要前者的结果，就需要用callable接口了。callable用法和runnable一样，只不过调用的是call方法，该方法有一个泛型返回值类型，你可以任意指定。
  • Future：Future可以从别的线程中得到函数返回值。Future可以监视目标线程调用call的情况，当你调用Future的get()方法以获得结果时，当前线程就开始阻塞，直到call方法结束返回结果。

参考《Java多线程编程中Future模式的详解》