零零散散接近一个月的课余时间,学完Java8InAction和Guava,感触很多,收获也很大,特别开心,接下来会利用空余时间学习Spark,希望自己在技术上慢慢积累,越来越从容。
对于Java8 最大的改变是lambda表达式 Collecotors CompletableFutures等 Funtional Programing.的思想真的很强大
自定义Future的实现
package com.company.LambdaExpressions.Futures;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
/**
* Created by mengxiaopeng on 2018/3/9.
* com.company.LambdaExpressions.Futures
* 自定义的实现一个Future 实现Executors.newCachedThreadPool().submit() submit功能
* 1.submit里面的Callable是交给Future里面的new Thread()来处理,返回值存在Future 不会block住主线程
* 2.当不采用while循环时 一般情况下获取不到Future里存的Callable的值 但是不会block住主线程
* 3.当需要获取Future值时 采用while+Thread休眠的方式 但是会block住主线程
* 4.如果想主线程一直挂起 可以使用Join的方式
* ===============
* MyFutureInAction2 会在这个基础上注册一个Listen监听 当存在值后通知调用者线程
* 好处:不阻塞主线程 Future执行完后会通知调用者 不用采用while方式获取Callable的返回值
*/
public class MyFutureInAction {
public static void main(String[] args) {
//######测试自定义 submit()
Future<String> submitFuture = submit(() -> {
try {
Thread.sleep(10000);
return "Success";
} catch (InterruptedException e) {
e.printStackTrace();
return "Error";
}
});
//这样处理时不会阻塞住 由于submit里面的Callable是交给Future里面的线程来处理的
System.out.println("1==main=no==Blocker===");
//缺点是 当需要获取future的值时 获取不到时 主线程不会Block住
String value = submitFuture.get();
System.out.println("2==main=no==Blocker====value=["+value+"]");
//缺点是 当需要获取future的值时 必须采用while循环判断是否执行完 主线程仍然被Block住了
while (!submitFuture.isDone()){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
value = submitFuture.get();
System.out.println("3==main=be==Blocker====value=["+value+"]");
//######测试自定义 blockSubmit()
String blockValue = blockSubmit(() -> {
try {
Thread.sleep(10);
return "BlockSuccess";
} catch (InterruptedException e) {
e.printStackTrace();
return "BlockError";
}
});
System.out.println("4==main=must be==Blocker====value=["+blockValue+"]");
//###主线程被挂起
try {
System.out.println("5===main==always=online.....=====");
Thread.currentThread().join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* 这里采用Block方式 实现submit 调用者线程会被Block住
* @param callable
* @param <T>
* @return
*/
private static <T> T blockSubmit(Callable<T> callable){
return callable.action();
}
/**
* Executors.newCachedThreadPool().submit()
* 自定义实现了上面的功能
* @param callable
* @param <T>
* @return 更加理解Future底层采用的方式
*/
private static <T> Future<T> submit(Callable<T> callable) {
AtomicReference<T> result = new AtomicReference<T>();
AtomicBoolean isFlag = new AtomicBoolean(false);
new Thread(() -> {
T action = callable.action();
result.set(action);
isFlag.set(true);
}).start();
Future<T> future = new Future<T>() {
@Override
public T get() {
T t = result.get();
return t;
}
@Override
public boolean isDone() {
return isFlag.get();
}
};
return future;
}
/**
* 定义Future 将来由future返回
* @param <T>
*/
public interface Future<T> {
T get();
boolean isDone();
}
/**
* 定义Callable的接口 具体需要做的事情
* 可以采用lamdba表达式
* @param <T>
*/
private interface Callable<T> {
T action();
}
}