Future Pattern

最新推荐文章于 2017-12-04 20:27:46 发布

TimeTDIT

最新推荐文章于 2017-12-04 20:27:46 发布

阅读量437

点赞数 1

分类专栏： java多线程设计模式文章标签：多线程多线程设计模式 Future Pattern

本文链接：https://blog.csdn.net/qq_35580883/article/details/78677411

版权

java多线程设计模式专栏收录该内容

12 篇文章 0 订阅

订阅专栏

什么是Future Pattern?

我现在去蛋糕店买蛋糕，下订单后，店员请我天黑之后再来取货，给我一张提货单。黄昏以后，我拿着提货单到蛋糕店取货，店员依据我的取货单，将蛋糕给了我。

假如现在需要一个执行起来需要一定时间的方法，我们就不需要执行结果出来了，而是直接获取一张“提货单”，因为获取“提货单”不需要花费时间，这时这个“提货单”就是Future参与者。

获取了Future参与者的线程，会在事后再去获取执行结果，就好像拿提货单去领取蛋糕一样。如果有了执行结果就马上取走蛋糕，否则等待到执行结果出现。

和往常一样，让我们还是先来看代码：

首先写一个Data接口，表达数据访问方式，让FutureData和RealData都实现这个接口：

package futurePattern;

public interface Data {
    public abstract String getContent();
}

然后写一个RealData类，用来表达实际数据：

package futurePattern;

public class RealData implements Data {
    private final String content;
    public RealData(int count, char c) {
        System.out.println("        making RealData(" + count + ", " + c + ") BEGIN");
        char[] buffer = new char[count];
        for (int i = 0; i < count; i++) {
            buffer[i] = c;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
        }
        System.out.println("        making RealData(" + count + ", " + c + ") END");
        this.content = new String(buffer);
    }
    public String getContent() {
        return content;
    }
}

然后写一个FutureData类，作为Future（提货单）：

package futurePattern;

public class FutureData implements Data {
    private RealData realdata = null;
    private boolean ready = false;
    public synchronized void setRealData(RealData realdata) {
        if (ready) {                        
            return;     // balk
        }
        this.realdata = realdata;
        this.ready = true;
        notifyAll();
    }
    public synchronized String getContent() {
        while (!ready) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        return realdata.getContent();
    }
}

接下来是对请求返回FutureData实例的类Host：

package futurePattern;

public class Host {
    public Data request(final int count, final char c) {
        System.out.println("    request(" + count + ", " + c + ") BEGIN");

        // (1) 建立FutureData的实体
        final FutureData future = new FutureData();

        // (2) 为了建立RealData的实体，启动新的线程
        new Thread() {                                      
            public void run() {                             
                RealData realdata = new RealData(count, c);
                future.setRealData(realdata);
            }                                               
        }.start();                                          

        System.out.println("    request(" + count + ", " + c + ") END");

        // (3) 取回FutureData实体，作为传回值
        return future;
    }
}

最后写一个测试类Test：

package futurePattern;

public class Test {
    public static void main(String[] args) {
        System.out.println("main BEGIN");
        Host host = new Host();
        Data data1 = host.request(10, 'A');
        Data data2 = host.request(20, 'B');
        Data data3 = host.request(30, 'C');

        System.out.println("main otherJob BEGIN");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
        }
        System.out.println("main otherJob END");

        System.out.println("data1 = " + data1.getContent());
        System.out.println("data2 = " + data2.getContent());
        System.out.println("data3 = " + data3.getContent());
        System.out.println("main END");
    }
}

运行结果如下：

好，现在我们回头看看我们写了什么，程序的关键在哪。

在测试类Test中我们可以看到，程序执行了sleep，实际上是模拟在这个时间我们可以去做一些其他的事。

发出请求之后返回的data1，data2，data3是我们所说的future，这个东西的获取和我们真正想要的东西相比简直不花时间。

然后我们就可以通过future的getContent方法获取我们真正想要的。

在Host类中，他的request方法会建立一个FutureData实例，然后成为这个方法的返回值。

在这个类中会产生RealData的实例，不过是交给新的线程进行的。当RealData实例建立以后，就调用了setRealData方法，设置给future（相当于蛋糕做好了，准备让客人来取）。

总之调用request的线程（相当于买蛋糕的客人），做了以下操作：

1、建立FutureData的实例

2、为了建立RealData的实例，启动新的线程

3、取回FutureData，作为返回值

另外在这个类中，我们看到了一个request方法，这个方法不是synchronized的，但是实际上，这个方法也是线程安全的，因为request的参数和局部变量都是由单独的线程拥有的，而不是多个线程共享的。

而且request方法的参数和局部变量都被申明成了final，是为了在匿名内部类中使用。

在FutureData这个提货单类中，有一个ready字段，当蛋糕做好之后，可以把ready设置为true，然后调用notifyAll，唤醒所有在getContent方法里等待的线程。

另外setRealData中使用了Balking Pattern，防止setRealData被调用两次以上。

在getContent方法当中，由于必须等待setRealData方法设置realdata，因此这里用ready作为防卫条件，使用了Guarded Suspension Pattern，最后返回真实数据。当RealData实例被设置好之后，访问getContent方法而进入wait set的线程就会被notifyAll唤醒。

对于RealData类，作用只有返回真实数据，这个类没有用到synchronized，不处理等待到实例建立好为止的线程控制操作。不需要考虑多线程环境。

Future Pattern对这种需要很多时间的普通类加上提货单机制，使得多线程化后仍然可以提高执行性能。

Future Pattern的所有参与者

1、Client（委托人）参与者

Client参与者向Host参与者发出请求，Client参与者会马上得到VirtualData参与者，作为这个请求的返回值（实际上就是我们所说的future）。

2、Host参与者

Host参与者会建立出新的线程，开始建立RealData参与者。另一方面，对Client参与者（以VirtualData参与者的形式）返回VirtualData参与者。

3、VirtualData（虚拟的数据）参与者

VirtualData是用来统一代表Future参与者和RealData参与者的，相当于一个data接口。

4、Future（期货）参与者

Future是Host参与者传给Client参与者，被当作提货单的参与者。

Future Pattern 的优点