老生常谈java中的Future模式
在 Java 中，Future 模式是一种常用的设计模式，用于处理并发编程中的多线程问题。在这个模式中，线程 A 需要等待线程 B 的结果，但线程 A 不需要一直等待线程 B，可以先拿到一个未来的 Future，然后等线程 B 有了结果后再取真实的结果。
Future 模式的执行原理是：当线程 A 需要线程 B 的结果时，线程 A 首先获取一个 Future，然后继续执行其他任务，而不需要等待线程 B 的结果。当线程 B 完成计算后，会将结果设置到 Future 中，这时线程 A 可以通过 get 方法获取真实的结果。
在 Java 中，Future 模式可以使用 ExecutorService 和 Callable 实现。下面是一个简单的示例代码：
```java
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(callable);
// 主线程需要 callable 线程的结果，先拿到一个未来的 Future
System.out.println(future.get()); // 有了结果后再根据 get 方法取真实的结果
```
在这个示例中，主线程首先提交一个 Callable 任务，然后获取一个 Future。当 Callable 任务完成计算后，主线程可以通过 get 方法获取真实的结果。
我们也可以自己实现一个 Future 模式。下面是一个示例实现：
```java
package com.future;
/
* 数据结果
* Created by yulinfeng on 6/18/17.
*/
public interface Data {
String getResult() throws InterruptedException;
}
package com.future;
/
* 结果的真实计算过程
* Created by yulinfeng on 6/18/17.
*/
public class RealData implements Data {
protected String data;
public RealData(String data) {
try {
System.out.println("正在计算结果");
Thread.sleep(3000); // 模拟计算
} catch (InterruptedException e) {
e.printStackTrace();
}
this.data = data + “ world”;
}
public String getResult() throws InterruptedException {
return data;
}
}
package com.future;
/
* 真实结果 RealData 的代理
* Created by yulinfeng on 6/18/17.
*/
public class FutureData implements Data {
RealData realData = null; // 对 RealData 的封装，代理了 RealData
boolean isReady = false; // 真实结果是否已经准备好
public synchronized void setResultData(RealData realData) {
if (isReady) {
return;
}
this.realData = realData;
isReady = true;
notifyAll(); // realData 已经被注入到了 futureData 中，通知 getResult 方法
}
public synchronized String getResult() throws InterruptedException {
if (!isReady) {
wait(); // 数据还未计算好，阻塞等待
}
return realData.getResult();
}
}
package com.future;
/
* Client 主要完成的功能包括：1. 返回一个 FutureData ；2. 开启一个线程用于构造 RealData
* Created by yulinfeng on 6/18/17.
*/
public class Client {
public Data request(final String string) {
final FutureData futureData = new FutureData();
/* 计算过程比较慢，单独放到一个线程中去 */
new Thread(new Runnable() {
@Override
public void run() {
RealData realData = new RealData(string);
futureData.setResultData(realData);
}
}).start();
return futureData;
}
}
```
在这个示例中，我们定义了一个接口 `Data`，一个真实计算过程的类 `RealData`，一个代理类 `FutureData`，和一个客户端类 `Client`。客户端类 `Client` 负责返回一个 `FutureData`，并开启一个线程用于构造 `RealData`。当 `RealData` 完成计算后，会将结果设置到 `FutureData` 中，然后客户端可以通过 `getResult` 方法获取真实的结果。
Future 模式的优点是可以提高系统的并发性和响应性。它允许不同的线程之间进行异步通信，提高了系统的整体性能。然而，Future 模式也存在一些缺点，例如需要合理地管理线程和锁，以免出现死锁和其他问题。
Future 模式是一种常用的设计模式，用于处理并发编程中的多线程问题。它可以提高系统的并发性和响应性，但也需要合理地管理线程和锁，以免出现问题。
