JUC-实现Future

JUC-实现Future

Future 为异步执行结果

实现

Future

public interface Future<T> {

    T get() throws InterruptedException;

    boolean isDone();
}

FutureTask

FutureTask 是 Future 的实现

public class FutureTask<T> implements Future<T> {

    private T result;
    private Object lock = new Object();
    private boolean isDone;

    @Override
    public T get() throws InterruptedException {
        synchronized (lock) {
            while (!isDone) {
                lock.wait();
            }
            return result;
        }
    }

    protected void finish(T result) {
        synchronized (lock) {
            this.result = result;
            isDone = true;
            lock.notifyAll();
        }
    }

    @Override
    public boolean isDone() {
        return isDone;
    }
}

FutureService

public interface FutureService<IN,OUT> {

    Future<?> submit(Runnable task);

    Future<OUT> submit(Task<IN, OUT> task, IN in);


    static <T,R> FutureService<T,R> newInstance() {
        return new FutureServiceImpl();
    }
}

FutureServiceImpl

public class FutureServiceImpl<IN,OUT> implements FutureService<IN, OUT> {

    @Override
    public Future<?> submit(Runnable task) {
        FutureTask<Void> result = new FutureTask<>();
        new Thread(()->{
            task.run();
            result.finish(null);
        }).start();
        return result;
    }

    @Override
    public Future<OUT> submit(Task<IN, OUT> task, IN in) {
        FutureTask<OUT> result = new FutureTask<>();
        new Thread(()->{
            OUT execute = task.execute(in);
            result.finish(execute);
        }).start();
        return result;
    }
}

Task

public interface Task<IN, OUT> {

    OUT execute(IN in);
}

测试

public class FutureMain {


    public static void run1() throws Exception {
        FutureService<Void, Void> futureService = FutureService.newInstance();
        Future<?> future = futureService.submit(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("I am finished");
        });
        future.get();
        System.out.println("main thread finished");
    }

    public static void run2() throws Exception {
        FutureService<String, String> futureService = FutureService.newInstance();
        Future<String> future = futureService.submit((input) -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return input.concat(" I am finished");
        }, "hello");
        System.out.println(future.get());
        System.out.println("main thread finished");
    }

    public static void main(String[] args) throws Exception {
        run1();
        run2();
    }
}