多线程中的“回调”

回调：类A的a()方法调用类B的b()方法；类B的b()方法执行完毕主动调用类A的callback()方法，这是一种双向调用的方式。

这里其实不是本质意义上的回调，这里是调用者主动调用get方法阻塞获取返回值。

package com.xsl.test;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

import org.junit.Test;

public class 多线程中的回调 {
    // 回调获取返回值
    @Test
    public void test () {
        try {
            /**
             * 方式一：Executors+Future方式
             */
            ExecutorService executor = Executors.newCachedThreadPool();
            Future<String> future = executor.submit(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    System.out.println("call");
                    TimeUnit.SECONDS.sleep(1);
                    return "str";
                }
            });
            // 手动阻塞调用get通过call方法获得返回值。
            System.out.println(future.get());
            // 需要手动关闭，不然线程池的线程会继续执行。
            executor.shutdown();
            
            /**
             * 方式二：FutureTask+Thread方式
             */
            // 使用futuretask同时作为线程执行单元和数据请求单元。
            FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    System.out.println("hello");
                    return new Random().nextInt();
                }
            });
            new Thread(futureTask).start();
            // 阻塞获取返回值
            System.out.println(futureTask.get());
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

返回结果如下：

call
str
hello
575489680