实现callbale接口的使用

线程池实现

import java.util.concurrent.Callable;
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.newSingleThreadExecutor();

        // 创建Callable任务
        Callable<String> task = new MyCallable();

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

        try {
            // 阻塞等待任务执行完成并获取结果
            String result = future.get();
            System.out.println("任务执行结果：" + result);
        } catch (Exception e) {
            e.printStackTrace();
        }

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

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 在此处编写任务的执行逻辑
        Thread.sleep(3000);  // 模拟耗时操作，如网络请求或数据处理
        return "Hello, Callable!";
    }
}

在上述代码中，我们首先创建了一个单线程的线程池ExecutorService executor = Executors.newSingleThreadExecutor();，然后定义了一个实现Callable接口的任务MyCallable。

通过调用executor.submit(task)方法将任务提交给线程池，并得到一个Future对象。通过Future对象的get()方法可以阻塞等待任务执行完成，并获取任务的返回结果。

注意，callable任务的call()方法需要抛出Exception异常，这样可以处理任务执行过程中可能抛出的异常。

最后，记得在不需要使用线程池时调用executor.shutdown()来关闭线程池。这将会等待所有已提交的任务执行完成并释放线程池的资源。

通过使用Callable接口创建线程，你可以灵活地控制线程的执行逻辑，并在需要时获取任务的执行结果。

FutureTask实现

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

public class CallableExample {
    public static void main(String[] args) {
        // 创建Callable任务
        Callable<String> task = new MyCallable();

        // 创建FutureTask对象，并将Callable任务作为构造函数参数
        FutureTask<String> futureTask = new FutureTask<>(task);

        // 创建线程，并将FutureTask作为Runnable传入
        Thread thread = new Thread(futureTask);

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

        try {
            // 阻塞等待任务执行完成并获取结果
            String result = futureTask.get();
            System.out.println("任务执行结果：" + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 在此处编写任务的执行逻辑
        Thread.sleep(3000);  // 模拟耗时操作，如网络请求或数据处理
        return "Hello, Callable!";
    }
}

在上述代码中，我们直接创建了一个Thread对象，并将FutureTask作为Runnable传入。FutureTask继承了Runnable接口，其内部包含了Callable任务，在执行线程时会调用Callable任务的call()方法。

通过调用futureTask.get()方法阻塞等待任务执行完成并获取结果。

使用这种方式创建线程，你可以直接控制线程的执行，并获取任务的执行结果。然而，线程池的优势在于可以统一管理和复用线程资源，适用于大规模的并发任务处理。所以，在实际应用中，推荐优先使用线程池来管理线程，除非有特殊需求需要手动创建线程。