Java中callable的实现原理

public interface Runnable {
    void run();
}

// 使用示例
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Running a task in a thread...");
    }
    
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
    }
}

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int result = someComputation(); // 假设这是个计算方法
        return result;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable callable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();

        // 获取线程执行完成后的结果
        Integer computedResult = futureTask.get();
        System.out.println("Computed result: " + computedResult);
    }
}

import java.util.concurrent.Future;

// 通常不直接实现 Future 接口，而是由其他类如 FutureTask 实现
public class FutureExample {
    public void executeTaskWithFuture() throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> future = executor.submit(new MyCallable());

        // 可以做其他事情，然后...
        // 当需要结果时，调用 get() 方法会阻塞直到结果准备好
        Integer result = future.get();
        System.out.println("Result from Future: " + result);

        // 关闭线程池
        executor.shutdown();
    }
}

import java.util.concurrent.RunnableFuture;

// 不直接实现 RunnableFuture，而是使用 FutureTask 等已实现它的类
class MyRunnableFuture extends FutureTask<Integer> {
    public MyRunnableFuture(Callable<Integer> callable) {
        super(callable);
    }
    
    public void customMethod() {
        // 可以添加额外的自定义方法
    }
}

import java.util.concurrent.FutureTask;

public class FutureTaskExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建一个 FutureTask，传入 Callable 对象
        FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable());

        // 创建一个线程来执行这个任务
        Thread thread = new Thread(futureTask);
        thread.start();

        // 或者将 FutureTask 提交到 ExecutorService
        // ExecutorService executor = Executors.newSingleThreadExecutor();
        // executor.execute(futureTask);

        // 获取结果
        Integer result = futureTask.get();
        System.out.println("Result from FutureTask: " + result);
    }
}