Callble接口创建多线程【详细总结】

Callble接口介绍

Callable是一个创建线程时使用的一个接口，它和Runnable作用相似，Runnable在创建多线程的时候是没有返回值的，但是Callable它是带有返回值的。我们一般想要有返回值的多线程的时候就可以使用Callable。

callble和runable的不同

• 名称不同
• 重写方法不同，Callable中是call()方法，而Runnable中是run()方法
• 是否带泛型，其中Callable接口带有泛型，而Runnable接口不带有泛型
• 是否有返回值，其中Callable接口有返回值，返回值类型和泛型类型一致
• 构建方式不同，其中Callable接口用的是FutureTask类作为媒介来联系上Runnable接口

Future 接口

当 call（）方法完成时，结果必须存储在主线程已知的对象中，以便主线程可以知道该线程返回的结果。为此，可以使用 Future 对象。

将 Future 视为保存结果的对象–它可能暂时不保存结果，但将来会保存（一旦Callable 返回）。Future 基本上是主线程可以跟踪进度以及其他线程的结果的一种方式。要实现此接口，必须重写 5 种方法，这里列出了重要的方法,如下：

public boolean cancel（boolean mayInterrupt）//：用于停止任务。
1

如果尚未启动，它将停止任务。如果已启动，则仅在 mayInterrupt 为 true时才会中断任务。

`public Object get（）//抛出 InterruptedException，ExecutionException：用于获取任务的结果`。
1

如果任务完成，它将立即返回结果，否则将等待任务完成，然后返回结果。

public boolean isDone（）：//如果任务完成，则返回 true，否则返回 false
1

可以看到 Callable 和 Future 做两件事-Callable 与 Runnable 类似，因为它封装了要在另一个线程上运行的任务，而 Future 用于存储从另一个线程获得的结果。实际上，future 也可以与 Runnable 一起使用。要创建线程，需要 Runnable。为了获得结果，需要 future。

FutureTask类

FutureTask类实现了RunnableFuture接口，而RunnnableFuture接口继承了Runnable和Future接口，所以说FutureTask是一个提供异步计算的结果的任务。
FutureTask可以用来包装Callable或者Runnbale对象。因为FutureTask实现了Runnable接口，所以FutureTask也可以被提交给Executor

大家可以跟着看一下里面的源码：
FutureTask构造器

// 创建一个FutureTask，一旦运行就执行给定的Callable
public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}
// 创建一个FutureTask，一旦运行就执行给定的Ru你那边了，并安排成功完成时get返回给定的结果
public FutureTask(Runnable runnable, V result) {
    this.callable = Executors.callable(runnable, result);
    this.state = NEW;       // ensure visibility of callable
}

1
2
3
4
5
6
7
8
9
10
11
12
13

其他常用的代码：

// get()获取结果
public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    return report(s);
}
// outcome就是返回值
private V report(int s) throws ExecutionException {
    Object x = outcome;
    if (s == NORMAL)
        return (V)x;
    if (s >= CANCELLED)
        throw new CancellationException();
    throw new ExecutionException((Throwable)x);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

callable接口创建多线程

借助FutureTask执行

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"执行Runnable");
        }).start();
        FutureTask<String> task = new FutureTask<>(() -> {
            System.out.println(Thread.currentThread().getName() + "使用Callable接口");
            return "Callable接口返回值";
        });
        new Thread(task).start();
        System.out.println("Callable返回值：" + task.get());
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出为：

Thread-0执行Runnable
Thread-1使用Callable接口
Callable返回值：Callable接口返回值

1
2
3
4

小结(重点)

1，在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 Future 对象在后台完成, 当主线程将来需要时，就可以通过 Future对象获得后台作业的计算结果或者执行状态。
2，一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。
3，仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法。一旦计算完成，就不能再重新开始或取消计算。get 方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。
4，只计算一次。