Java8学习计划--关于多核多线程并发编程-自定义Future的实现

零零散散接近一个月的课余时间，学完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();
    }
}