`Callable` 是 Java 中的一个接口，与 `Runnable` 接口类似，但它可以返回一个结果并且能抛出异常。

`Callable` 是 Java 中的一个接口，与 `Runnable` 接口类似，但它可以返回一个结果并且能抛出异常。`Callable` 任务通常与 `FutureTask` 配合使用，以获取异步执行的结果。

以下是 `Callable` 接口的基本使用方法：

1. **定义一个 Callable 任务**：创建一个类实现 `Callable` 接口，并实现 `call` 方法。

```java
import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 执行一些计算任务
        String result = "Result of the callable task";
        return result;
    }
}
```

2. **使用 ExecutorService 执行 Callable 任务**：创建一个 `ExecutorService` 来提交 `Callable` 任务，并返回一个 `Future` 对象，该对象可以用来获取任务的结果。

```java
import java.util.concurrent.*;

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

        // 提交 Callable 任务
        Future<String> future = executorService.submit(new MyCallable());

        try {
            // 获取任务结果
            String result = future.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            executorService.shutdown();
        }
    }
}
```

3. **处理异常**：`call` 方法可以抛出异常，这些异常可以通过 `Future.get()` 方法的 `ExecutionException` 被捕获。

4. **使用 FutureTask**：`FutureTask` 是 `Future` 和 `Runnable` 的实现，它可以用来包装一个 `Callable` 对象。

```java
FutureTask<String> futureTask = new FutureTask<>(new MyCallable());

// 可以在新线程中执行 futureTask
new Thread(futureTask).start();

try {
    // 获取任务结果
    String result = futureTask.get();
    System.out.println(result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}
```

5. **取消任务**：如果任务尚未完成，可以通过 `Future.cancel(boolean mayInterruptIfRunning)` 方法取消任务。

```java
// 取消任务
future.cancel(true); // 如果正在运行，中断运行
```

6. **检查任务状态**：可以通过 `Future.isDone()` 方法检查任务是否已完成。

Callable 接口通常用于需要返回结果或抛出异常的并发任务。它提供了一种简单的方式来实现异步计算。