FutureTask和Callable

FutureTask

• FutureTask是Future的实现类，它实现了Runnable接口，所以可以被线程执行。
• FutureTask可以用来包装Callable或者Runnable对象。
• FutureTask可以用来获取异步计算的结果。
• FutureTask的使用方法：
  • 创建一个Callable对象。
  • 创建一个FutureTask对象，将Callable对象传递给FutureTask的构造方法。
  • 创建一个Thread对象，将FutureTask对象传递给Thread的构造方法。
  • 调用Thread对象的start()方法启动线程。
  • 调用FutureTask对象的get()方法获取异步计算的结果。
  • 代码示例：

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

public class FutureTaskDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建一个Callable对象
        Callable<Integer> callable = () -> {
            System.out.println("Callable is running...");
            return 1;
        };

        // 创建一个FutureTask对象
        FutureTask<Integer> futureTask = new FutureTask<>(callable);

        // 创建一个Thread对象
        Thread thread = new Thread(futureTask);

        // 启动线程
        thread.start();

        // 获取异步计算的结果
        Integer result = futureTask.get();
        System.out.println("result: " + result);
    }
}

Callable

• Callable接口类似于Runnable，但是Runnable不会返回结果，并且无法抛出返回结果的异常，而Callable可以。
• Callable接口的call()方法可以返回一个结果，这个结果可以在FutureTask中被获取。
• Callable接口的使用方法：
  • 创建一个Callable对象。
  • 创建一个FutureTask对象，将Callable对象传递给FutureTask的构造方法。
  • 创建一个Thread对象，将FutureTask对象传递给Thread的构造方法。
  • 调用Thread对象的start()方法启动线程。
  • 调用FutureTask对象的get()方法获取异步计算的结果。
  • 代码示例：

package io.alex.concurrent;

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;

public class CallableExample {
    public static void main(String[] args) {
        // 创建一个线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 创建一个Callable任务
        Callable<Integer> task = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 10; i++) {
                    sum += i;
                    Thread.sleep(100); // 模拟一些耗时的计算
                }
                return sum;
            }
        };

        // 提交任务并获取Future对象
        Future<Integer> future = executor.submit(task);

        // 主线程继续执行其他任务
        System.out.println("Main thread is doing something else...");

        try {
            // 获取Callable任务的结果
            Integer result = future.get(); // 这个调用会阻塞，直到任务完成
            System.out.println("Result from Callable: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

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