适用的情况
当一个线程向其他线程委托了处理, 然后还想要得到处理结果时.
实现的方式
编写一个与处理结果具有相同接口的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");
}
}
