Runnable、Callable、Future、FutureTask 及应用是怎样的

在Java并发编程中，Runnable、Callable、Future和FutureTask是非常重要的接口和类，它们为多线程编程提供了强大的支持。本文将详细介绍这些概念及其应用场景。

1. Runnable

1.1 概述

Runnable是Java中最基础的线程接口，它定义了一个run()方法，用于执行线程的任务。Runnable接口的声明如下：

public interface Runnable {
    void run();
}

1.2 使用场景

Runnable通常用于定义线程任务，并通过Thread类来启动线程。例如：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

1.3 优缺点

• 优点：简单易用，适合不需要返回值的任务。
• 缺点：无法返回任务执行结果，无法抛出受检异常。

2. Callable

2.1 概述

Callable是Java 5引入的接口，与Runnable类似，但它可以返回一个结果，并且可以抛出异常。Callable接口的声明如下：

public interface Callable<V> {
    V call() throws Exception;
}

2.2 使用场景

Callable通常与ExecutorService一起使用，通过submit()方法提交任务，并返回一个Future对象。例如：

import java.util.concurrent.*;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Task completed";
    }
}

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyCallable());
        System.out.println(future.get());
        executor.shutdown();
    }
}

2.3 优缺点

• 优点：可以返回任务执行结果，可以抛出受检异常。
• 缺点：使用相对复杂，需要与ExecutorService和Future配合使用。

3. Future

3.1 概述

Future是Java 5引入的接口，用于表示异步计算的结果。它提供了检查计算是否完成的方法，以及获取计算结果的方法。Future接口的声明如下：

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

3.2 使用场景

Future通常与Callable一起使用，通过ExecutorService的submit()方法提交任务，并返回一个Future对象。例如：

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(() -> "Task completed");
        System.out.println(future.get());
        executor.shutdown();
    }
}

3.3 优缺点

• 优点：可以获取异步任务的结果，支持取消任务。
• 缺点：获取结果时可能会阻塞线程，不支持任务完成时的回调。

4. FutureTask

4.1 概述

FutureTask是Future接口的一个实现类，同时实现了Runnable接口。它既可以作为Runnable被线程执行，又可以作为Future获取任务执行结果。FutureTask的声明如下：

public class FutureTask<V> implements RunnableFuture<V> {
    // 构造方法
    public FutureTask(Callable<V> callable) { ... }
    public FutureTask(Runnable runnable, V result) { ... }

    // 实现的方法
    public boolean isCancelled() { ... }
    public boolean isDone() { ... }
    public V get() throws InterruptedException, ExecutionException { ... }
    public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { ... }
    public void run() { ... }
    public boolean cancel(boolean mayInterruptIfRunning) { ... }
}

4.2 使用场景

FutureTask可以用于将Callable任务包装成Runnable，然后通过Thread或ExecutorService执行。例如：

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(() -> "Task completed");
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());
    }
}

4.3 优缺点

• 优点：结合了Runnable和Future的优点，既可以作为任务执行，又可以获取任务结果。
• 缺点：使用相对复杂，需要手动管理线程或线程池。

5. 应用场景

5.1 异步任务处理

Callable和Future通常用于处理需要返回结果的异步任务。例如，在Web服务器中处理用户请求时，可以使用Callable和Future来异步执行耗时操作，并在操作完成后返回结果。

5.2 任务取消

Future提供了cancel()方法，可以用于取消尚未完成的任务。这在需要中断长时间运行的任务时非常有用。

5.3 任务组合

FutureTask可以用于将多个任务组合在一起，形成一个更大的任务。例如，可以将多个Callable任务包装成FutureTask，然后通过ExecutorService并发执行。

6. 总结

Runnable、Callable、Future和FutureTask是Java并发编程中的重要工具，它们各自有不同的应用场景和优缺点。Runnable适合不需要返回值的简单任务，Callable适合需要返回结果的任务，Future用于获取异步任务的结果，FutureTask则结合了Runnable和Future的优点。在实际开发中，根据具体需求选择合适的工具，可以大大提高程序的并发性能和可维护性。