在Java中，可以使用Callable和Future创建线程。Callable接口类似于Runnable接口，但是它可以返回一个结果并且可以抛出异常。Future则是用于表示异步计算的结果，可以等待计算完成并且获取结果。
Callable 和 Future 的优点
使用Callable和Future创建线程相较于直接使用Runnable接口或Thread类有一些优点和好处：
- 能够返回结果：Callable接口可以返回计算的结果，这在某些场景下非常有用。例如，如果你需要执行一个耗时的计算任务，并且需要获取计算的结果进行后续处理，那么Callable就可以很方便地实现这个需求。
- 能够抛出异常 ：Callable接口的
call()方法可以声明抛出异常，这使得在执行过程中出现异常时能够更好地处理错误情况，而不是直接使线程崩溃。 - 更灵活的线程池管理：ExecutorService接口提供了灵活的线程池管理，可以方便地控制并发线程数量、提交任务、获取任务执行结果等。使用Callable和Future结合ExecutorService可以更加方便地管理并发任务。
- 阻塞等待任务完成 ：Future对象的
get()方法可以阻塞当前线程，直到任务执行完成并返回结果。这在需要等待任务执行完成后再继续执行后续操作时非常有用。 - 支持取消任务 ：Future对象提供了
cancel()方法，可以取消任务的执行。这在某些情况下可以帮助避免资源浪费或处理超时任务。
总的来说，使用Callable和Future创建线程能够提供更灵活、更可控的并发执行方式，使得多线程编程更加方便、高效、安全。
Callable 和 Future 的使用步骤
- 创建Callable任务 ：首先，你需要创建一个实现了Callable接口的任务类，该接口要求实现
call()方法，该方法表示需要执行的具体任务，并且可以返回一个结果。 - 创建ExecutorService：接下来，你需要创建一个ExecutorService对象，它用于管理线程池和执行任务。
- 提交任务 ：使用ExecutorService的
submit()方法提交Callable任务。这个方法会返回一个Future对象，用于表示任务的执行情况和结果。 - 获取Future对象 ：通过调用
submit()方法后返回的Future对象，你可以对任务进行管理，例如等待任务执行完成或者取消任务。 - 获取结果 ：如果你需要获取任务执行的结果，可以调用Future对象的
get()方法。这个方法会阻塞当前线程，直到任务执行完成并返回结果。 - 关闭ExecutorService ：当所有任务执行完成后，记得调用ExecutorService的
shutdown()方法关闭线程池，释放资源。
Callable 和 Future 的代码样例
下面是一个简单的示例，演示了如何使用Callable和Future创建线程：
java
import java.util.concurrent.*;
public class CallableAndFutureDemo {
public static void main(String[] args) {
// 创建一个线程
ExecutorService executor = Executors.newSingleThreadExecutor();
// 创建一个 Callable 任务
Callable<Integer> callable = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
// 模拟一个耗时操作
Thread.sleep(2000);
return 123;
}
};
// 提交任务并获取 Future 对象
Future<Integer> future = executor.submit(callable);
// 等待计算完成并获取结果
try {
// 这一步会阻塞，直到任务完成
Integer result = future.get();
System.out.println("result: " + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
// 关闭线程池
executor.shutdown();
}
}这个示例中，我们创建了一个Callable任务，并通过ExecutorService的submit()方法提交该任务。然后，我们通过Future对象的get()方法等待任务执行完成并获取结果。最后，我们调用ExecutorService的shutdown()方法关闭线程池。
FutureTask 的优点
当使用Callable和Future时，经常会使用到FutureTask类。FutureTask是Future接口的实现类，同时也实现了Runnable接口，因此它可以被提交到ExecutorService中执行，并且可以作为Future对象来获取任务的执行结果。
以下是FutureTask的优点和使用方法：
- 方便的结合Callable和Runnable：FutureTask既可以包装Callable任务，也可以直接包装Runnable任务，这使得使用FutureTask非常灵活，既可以获取任务执行结果，又可以在ExecutorService中执行。
- 简化线程管理：FutureTask提供了一种方便的方式来管理异步任务。通过将任务包装在FutureTask中，可以更容易地提交、取消、等待和获取任务的执行结果。
- 异常处理 ：FutureTask能够处理Callable任务中抛出的异常。如果任务执行过程中出现异常，调用FutureTask的
get()方法会抛出ExecutionException，并将原始异常作为其cause。 - 支持取消任务 ：FutureTask提供了
cancel()方法来取消任务的执行。可以选择传入一个布尔值参数来指定是否中断正在执行的任务。 - 支持多线程操作：FutureTask是线程安全的，可以在多个线程中安全地使用。
FutureTask 的示例代码1
使用FutureTask的示例代码如下：
java
import java.util.concurrent.*;
public class CallableAndFutureTaskDemo {
public static void main(String[] args) {
// 创建一个 Callable 任务
Callable<Integer> callable = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
// 模拟一个耗时操作
Thread.sleep(2000);
return 123;
}
};
// 提交任务并获取 Future 对象
FutureTask<Integer> future = new FutureTask<>(callable);
// 创建一个线程池
ExecutorService executor = Executors.newSingleThreadExecutor();
// 提交 FutureTask 任务
executor.submit(callable);
// 获取任务执行结果
try {
// 这一步会阻塞，直到任务完成
Integer result = future.get();
System.out.println("result: " + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
// 关闭线程池
executor.shutdown();
}
}在这个示例中，我们创建了一个Callable任务，并使用FutureTask包装了它。然后，我们将FutureTask提交到ExecutorService中执行，并通过调用get()方法获取任务的执行结果。最后，我们关闭了ExecutorService。
FutureTask 的示例代码2
使用 Callable, FutureTask 和 Thread，而不是线程池来创建线程，代码示例如下：
java
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableAndFutureTaskDemo1 {
public static void main(String[] args) {
// 创建一个Callable任务
Callable<Integer> callable = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
// 模拟一个耗时操作
Thread.sleep(2000);
return 123;
}
};
// 创建FutureTask对象
FutureTask<Integer> futureTask = new FutureTask<>(callable);
// 创建一个线程，并将FutureTask作为其构造函数参数
Thread thread = new Thread(futureTask);
// 启动线程
thread.start();
// 获取任务执行结果
try {
Integer result = futureTask.get(); // 这一步会阻塞直到任务完成
System.out.println("Result: " + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}在这个示例中，我们创建了一个Callable任务，并使用FutureTask包装了它。然后，我们创建了一个Thread对象，将FutureTask作为其构造函数参数传入，这样Thread就知道要执行的任务。接着，我们启动了线程并等待任务执行完成，最后获取任务的执行结果。