个人心得分享

Future模式

 
  • Jun 26, 2019

适用的情况

当一个线程向其他线程委托了处理, 然后还想要得到处理结果时.

实现的方式

编写一个与处理结果具有相同接口的Future类, 在处理的开始立马返回该Future对象, 然后等到被委托的线程处理完毕,再将处理结果设置到Future对象中.这样委托处理的线程就可以在自己觉得合适的时机去获取处理结果, 而不用一直阻塞到结果完成.

相关的模式

  • 在委托的方法等待处理结果的部分可以使用Guarded Suspension模式.
  • 要想在Thread-Per-Message模式中想要获取处理结果的时候可以使用Future模式.
  • 同上, 要想在Worker-Thread模式中获取处理结果也可以使用Future模式.

    代码示例:

    FutureData是其中的”Future”类的实现, 里面的RealData字段装载着真实要返回的数据, ready则是RealData是否准备完毕的状态flag.

package com.graphic.future;

public interface Data {
    String getContent();
}

package com.graphic.future;

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) {
                e.printStackTrace();
            }
        }
        System.out.println("    making RealData(" + count + "," + c + ") END");
        this.content = new String(buffer);
    }

    @Override
    public String getContent() {
        return content;
    }
}

package com.graphic.future;

/*
 * futureData 是data的取货单, 如果realData没有准备好, 那么就会使用wait()方法阻塞getContent方法.
 * 切记, setContent()中一定要调用 notifyAll(), 否则,调用futureData()的方法的进程会始终阻塞在getContent()方法中!
 *
 * 个人理解, workerThread pattern相比于threadPerMessage pattern(最初版本的做法, 不使用java.util.concurrent包)
 * 避免了线程启动和销毁的开销, 但是这两种pattern虽然不会阻塞方法的进行,但不能获得处理的返回值.
 *
 * 但future pattern既不会发生"阻塞", (这里的意思不是wait()方法, 也就是realData的生成过程中, 调用getContent()之前, 线程是自由.)
 * 其实这里也可以理解future 实现了"异步", 它将值生成的过程, 与获取值的过程 进行了分离, 以往值生成的过程, 线程只能傻乎乎在那里等着, 但现在该线程可以去
 * 做其他的事情了, 做完其他事情后, 再来利用完成的值, 完成最后的活动.
 * 举个例子: 我们想吃泡面的时候, 先把泡面泡上, 然后泡面泡好之前, 我们可以去看会书, 刷刷微博,知乎, 或者去楼下买杯饮品, 我们可以不傻乎乎的站在泡面前等着它泡好,
 *          只要在最后它泡好之后, 记得回来吃了它就行.
 */

public class FutureData implements Data {
    private boolean ready = false;
    private RealData realData;

    public synchronized void setContent(RealData realData) {
        if (ready) {
            return;
        }
        this.realData = realData;
        ready = true;
        notifyAll();
    }

    @Override
    public synchronized String getContent() {
        while (!ready) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return realData.getContent();
    }
}

package com.graphic.future;

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

        new Thread() {
            @Override
            public void run() {
                RealData realData = new RealData(count, c);
                futureData.setContent(realData);
            }
        }.start();
        return futureData;
    }
}

package com.graphic.future;

public class Main {
    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(20, 'C');

        System.out.println("main other job BEGIN");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

    }
}
Search