基于Callable+FutureTask实现异步线程执行 带返回结果

可以基于Callable+FutureTask可以实现异步线程执行 带返回结果

代码如下：

public interface MyCallable<V> {

    V call();
}

public class MyCallableImpl implements MyCallable<Integer> {

    @Override
    public Integer call() {
        try {
            System.out.println("子线程（"+Thread.currentThread().getName()+"）,子线程在执行耗时的代码");

            System.out.println("子线程（"+Thread.currentThread().getName()+"）,等待3秒后返回结果");
            Thread.sleep(3000) ;
        }catch (Exception e){

        }

        //耗时代码执行完后返回1
        return 1;
    }
}

public class MyFutureTask<V> implements Runnable {

    private MyCallable<V> MyCallable;
    private Object lock = new Object();
    private V result;

    public MyFutureTask(MyCallable MyCallable) {
        this.MyCallable = MyCallable;
    }

    @Override
    public void run() {
        // 获取到MyCallable 执行返回结果
        result = MyCallable.call();
        // 如果 call方法执行完毕 则唤醒当前阻塞的线程
        synchronized (lock)
        {
            lock.notify();
        }
    }

    /**
     * 调用get方法 当前线程就会阻塞。
     */
    public V get() {

        //获取子线程异步执行完毕之后的返回结果
        //主线程阻塞
        synchronized (lock)
        {
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        return result;
    }
}

public class TheadDemo {

    public static void main(String[] args){
        MyCallable myCallable = new MyCallableImpl();
        MyFutureTask<Integer> futureTask = new MyFutureTask<Integer>(myCallable);
        new Thread(futureTask).start();
        Integer result = futureTask.get();
        System.out.println("主线程（"+Thread.currentThread().getName()+"）获取子线程返回的结果为：" + result);
    }

}

返回结果：