/**
* Future --> 代表的是未来的一个凭据
* FutureTask --> 将你的调用逻辑进行了隔离
* FutureService --> 桥接 Future和 FutureTask
*/
public class SyncInvoker {
public static void main(String[] args) throws InterruptedException {
FutureService futureService = new FutureService();
//用了8的lambada特性,将行为一并传过去。
Future<String> future = futureService.submit(
() -> {
try {
System.out.println("工作开始");
Thread.sleep(3000);
System.out.println("工作结束");
} catch (InterruptedException e) {
e.printStackTrace();
}
return "最终的结果";
});
System.out.println("=====================");
System.out.println("线程不会阻塞,可以做些别的工作。");
System.out.println("=====================");
System.out.println(future.get());
}
}
方法的接受者
//函数式接口,用来存放、传递逻辑执行单元。
public interface FutureTask<T> {
T call();
}
拿结果传给桥接对象
public class FutureService {
public <T> Future<T> submit(final FutureTask<T> task) {
AsynFuture<T> asynFuture = new AsynFuture<>();
new Thread(() -> {
//逻辑执行结束后,把结果拿出来。
T result = task.call();
//把结果送出去。
asynFuture.done(result);
}).start();
return asynFuture;
}
}
输出结果
public interface Future<T> {
T get() throws InterruptedException;
}
控制结果的输出
public class AsynFuture<T> implements Future<T> {
private volatile boolean done = false;
private T result;
public void done(T result) {
synchronized (this) {
//获取结果
this.result = result;
System.out.println("result: "+result);
//修改通知表示符
this.done = true;
//通知阻塞的线程
this.notifyAll();
}
}
@Override
public T get() throws InterruptedException {
synchronized (this) {
while (!done) {
//如果没拿到结果,就让此线程等待。
this.wait();
}
}
return result;
}
}