Java中为什么需要Callable
在java中有两种创建线程的方法：
一种是继承Thread类，重写run方法：
-
public
class
TestMain {
-
public
static
void
main(
String[] args) {
-
MyThread t1 =
new
MyThread();
-
t1.
start();
-
}
-
}
-
class
MyThread
extends
Thread {
-
public
void
run(
) {
-
System.
out.
println(
"MyThread running...");
-
}
-
}
-
复制代码
第二种是使用Runnable创建一个线程：
-
public
class
TestMain {
-
public
static
void
main(
String[] args) {
-
Runnable r1 =
new
Runnable() {
-
@Override
-
public
void
run(
) {
-
System.
out.
println(
"Thread created with runnable running...");
-
}
-
};
-
Thread t1 =
new
Thread(r1);
-
t1.
start();
-
}
-
}
-
复制代码
其实这两种方式，底层都是执行Thread类的run方法：
无论使用这里的哪种方式创建线程，都无法在线程结束时return一个返回值。但是在非常多的场景下，我们都需要在线程执行结束时，将执行的结果封装为一个返回值返回给主线程(或者调用者线程)。因此java在1.5版本时，在java.util.concurrent包引入了Callable接口，用于线程执行完时return一个返回值。
Callable和Runnable的区别
Runnable和Callable都是接口，分别定义如下：
-
package java.lang;
-
-
/**
-
* The <code>Runnable</code> interface should be implemented by any
-
* class whose instances are intended to be executed by a thread. The
-
* class must define a method of no arguments called <code>run</code>.
-
* <p>
-
* @since JDK1.0
-
*/
-
@FunctionalInterface
-
public
interface
Runnable {
-
public
abstract
void
run
();
-
}
-
复制代码
-
package java.util.concurrent;
-
-
/**
-
* A task that returns a result and may throw an exception.
-
* Implementors define a single method with no arguments called
-
* {@code call}.
-
*
-
* <p>The {@code Callable} interface is similar to {@link
-
* java.lang.Runnable}, in that both are designed for classes whose
-
* instances are potentially executed by another thread. A
-
* {@code Runnable}, however, does not return a result and cannot
-
* throw a checked exception.
-
*
-
* <p>The {@link Executors} class contains utility methods to
-
* convert from other common forms to {@code Callable} classes.
-
*
-
* @see Executor
-
* @since 1.5
-
* @author Doug Lea
-
* @param <V> the result type of method {@code call}
-
*/
-
@FunctionalInterface
-
public
interface
Callable<V> {
-
/**
-
* @return computed result
-
* @throws Exception if unable to compute a result
-
*/
-
V
call
()
throws Exception;
-
}
-
复制代码
可以看出，Callable和Runnable主要有两点区别：
- 有返回值；
- 可以抛出异常（这里抛出的异常，会在future.get()时可以通过
ExectionException捕获）；
因此可以看出，Callable更加实用。这里举个Callable使用的例子：
-
Callable
callable
=
new
Callable<Integer>() {
-
@Override
-
public Integer
call
()
throws Exception {
-
int
i
=
new
Random().nextInt(
5);
-
try {
-
Thread.sleep(i *
1000);
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
return i;
-
}
-
};
-
复制代码
虽然Callable接口的call方法可以返回执行结果，但是有两个问题需要解决：
- 线程的创建只能通过
Runnable，通过Callable又如何创建线程？ - 如何获取执行结果？
答案是Future和RunnableFuture。
Future和RunnableFuture
Future是一个接口，看下定义：
-
package java.util.concurrent;
-
-
/**
-
* A {@code Future} represents the result of an asynchronous
-
* computation. Methods are provided to check if the computation is
-
* complete, to wait for its completion, and to retrieve the result of
-
* the computation. The result can only be retrieved using method
-
* {@code get} when the computation has completed, blocking if
-
* necessary until it is ready. Cancellation is performed by the
-
* {@code cancel} method. Additional methods are provided to
-
* determine if the task completed normally or was cancelled. Once a
-
* computation has completed, the computation cannot be cancelled.
-
* If you would like to use a {@code Future} for the sake
-
* of cancellability but not provide a usable result, you can
-
* declare types of the form {@code Future<?>} and
-
* return {@code null} as a result of the underlying task.
-
*
-
* @see FutureTask
-
* @see Executor
-
* @since 1.5
-
* @author Doug Lea
-
* @param <V> The result type returned by this Future's {@code get} method
-
*/
-
public
interface
Future<V> {
-
-
/**
-
* Attempts to cancel execution of this task. This attempt will
-
* fail if the task has already completed, has already been cancelled,
-
* or could not be cancelled for some other reason. If successful,
-
* and this task has not started when {@code cancel} is called,
-
* this task should never run. If the task has already started,
-
* then the {@code mayInterruptIfRunning} parameter determines
-
* whether the thread executing this task should be interrupted in
-
* an attempt to stop the task.
-
*
-
* <p>After this method returns, subsequent calls to {@link #isDone} will
-
* always return {@code true}. Subsequent calls to {@link #isCancelled}
-
* will always return {@code true} if this method returned {@code true}.
-
*
-
* @param mayInterruptIfRunning {@code true} if the thread executing this
-
* task should be interrupted; otherwise, in-progress tasks are allowed
-
* to complete
-
* @return {@code false} if the task could not be cancelled,
-
* typically because it has already completed normally;
-
* {@code true} otherwise
-
*/
-
boolean
cancel
(boolean mayInterruptIfRunning);
-
-
/**
-
* Returns {@code true} if this task was cancelled before it completed
-
* normally.
-
*
-
* @return {@code true} if this task was cancelled before it completed
-
*/
-
boolean
isCancelled
();
-
-
/**
-
* Returns {@code true} if this task completed.
-
*
-
* Completion may be due to normal termination, an exception, or
-
* cancellation -- in all of these cases, this method will return
-
* {@code true}.
-
*
-
* @return {@code true} if this task completed
-
*/
-
boolean
isDone
();
-
-
/**
-
* Waits if necessary for the computation to complete, and then
-
* retrieves its result.
-
*
-
* @return the computed result
-
* @throws CancellationException if the computation was cancelled
-
* @throws ExecutionException if the computation threw an
-
* exception
-
* @throws InterruptedException if the current thread was interrupted
-
* while waiting
-
*/
-
V
get
()
throws InterruptedException, ExecutionException;
-
-
/**
-
* Waits if necessary for at most the given time for the computation
-
* to complete, and then retrieves its result, if available.
-
*
-
* @param timeout the maximum time to wait
-
* @param unit the time unit of the timeout argument
-
* @return the computed result
-
* @throws CancellationException if the computation was cancelled
-
* @throws ExecutionException if the computation threw an
-
* exception
-
* @throws InterruptedException if the current thread was interrupted
-
* while waiting
-
* @throws TimeoutException if the wait timed out
-
*/
-
V
get
(long timeout, TimeUnit unit)
-
throws InterruptedException, ExecutionException, TimeoutException;
-
}
-
复制代码
可以看出，Future可以用来表示线程的未来执行结果：一个容器，这个容器内将来存放的是线程的执行结果，线程执行完之前该容器内没有值，但是线程一旦执行成功（Callable的call方法返回之后），就会将结果存入该容器。从Future的接口定义可看出，Future不仅支持阻塞获取执行结果，还支持取消任务的执行，判断任务是否执行完成等。因此通过Future，主线程(或者调用者线程)可以跟进子现场的执行情况。
Callable其实和Runnable很像，都会执行一个任务，只不过Callable可以返回执行的结果。一般将执行结果封装到Future，调用者线程即可以通过Future获取Callable的执行结果了。因此，一般Callable会和Future搭配使用。
但是问题来了：java创建线程，需要Runnable，获取执行结果又需要Future。因此RunnableFuture来了：
可以看出，通过RunnableFuture，既可以创建线程，又可以获取线程的执行结果，当然RunnableFuture也是一个接口，我们一般情况下会使用它的具体实现类FutureTask。
那可能又有人要问了，Callable又是如何建立联系的呢？看下FutureTask的使用方式就明白了：
-
public
class
TestMain {
-
public
static
void
main
(String[] args) {
-
Callable
callable
=
new
Callable<Integer>() {
-
@Override
-
public Integer
call
()
throws Exception {
-
int
i
=
new
Random().nextInt(
5);
-
try {
-
Thread.sleep(i *
1000);
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
return i;
-
}
-
};
-
-
/**
-
* callable创建futureTask
-
* FutureTask实现了RunnableFuture接口，因此即是Runnable又是Future
-
* 作为Runnable可以传入Thread创建线程并执行
-
* 作为Future，可以用来获取执行的结果。
-
* 这里创建出来的futureTask对象有人称为"具柄"或者"存根"，大家可以理解为用来获取线程执行结果的一个"引用"即可。
-
*/
-
FutureTask<Integer> futureTask =
new
FutureTask<Integer>(callable);
-
-
// 作为Runnable使用
-
Thread
thread
=
new
Thread(futureTask);
-
thread.start();
-
-
try {
-
// 作为Future使用
-
Integer
integer
= futureTask.get();
-
System.out.println(integer);
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
catch (ExecutionException e) {
-
e.printStackTrace();
-
}
-
}
-
}
-
复制代码
因此FutureTask是Callable到Runnable的桥梁。
不使用Callable和Future，仅使用Runnable实现相同功能
下面我们看下，如果不使用Callable和Future，仅使用Runnable如何实现返回值。
-
public
class
TestMain {
-
public
static
void
main(
String[] args) {
-
MyRunnable myRunnable =
new
MyRunnable();
-
Thread t1 =
new
Thread(myRunnable);
-
t1.
start();
-
Object o = myRunnable.
get();
-
System.
out.
println(o);
-
}
-
}
-
-
class
MyRunnable
implements
Runnable {
-
// 存储执行结果
-
private
Object outCome =
null;
-
-
@Override
-
public
void
run(
) {
-
int i =
new
Random().
nextInt(
5);
-
try {
-
Thread.
sleep(i *
1000);
-
}
catch (
InterruptedException e) {
-
e.
printStackTrace();
-
}
-
// 存储执行结果
-
outCome = i;
-
// 产出结果后唤醒等待的get方法
-
synchronized (
this) {
-
notifyAll();
-
}
-
}
-
-
public synchronized
Object
get(
) {
-
while(outCome ==
null) {
-
try {
-
// 等待产出结果
-
wait();
-
}
catch (
InterruptedException e) {
-
e.
printStackTrace();
-
}
-
}
-
return outCome;
-
}
-
}
-
复制代码
可以看出，通过Runnable实现更加麻烦，因此这也体现出了Callable+Future的优势。
本篇博文主要参考了Callable and Future in Java和Future and FutureTask in java，感兴趣的话可以阅读原文。
转载：https://blog.csdn.net/BASK2311/article/details/127958849
查看评论