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();
    }
}