Java多线程基础-16：简述Java并发编程JUC中的Callable接口

JUC是 java.util.concurrent 这个包的简写，其中存放了Java并发框架为协调并发任务所提供的一些工具。本文介绍其中的Callable接口，以及与Callable的使用相关的Future、FutureTask。

目录

一、什么是Callable接口？

二、Callable接口的简单使用

Future

FutureTask

完整代码

三、总结：Callable

1、理解Callable

2、创建线程的方式汇总

（1）继承Thread类

（2）实现Runnable接口（匿名内部类同理）

（3）使用lambda表达式（最常用）

（4）实现Callable

---

一、什么是Callable接口？

Callable 和 Runnable 相对，都是描述一个 “任务”。Callable 描述的是带有返回值的任务，而Runnable 描述的是不带返回值的任务。

可以把Runnable想象成一个没有参数和返回值的异步方法，而Callable与Runnable类似，但是是有返回值的，方便程序员借助多线程的方式计算结果。

Callable 接口是一个函数式接口，只有一个方法 call()：

类型参数V就是call方法返回值的类型。例如，Callable<Integer>就表示一个最终返回Integer对象的异步计算：

        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                ...
            }
        };

我们来看一下Callable的简单使用。

二、Callable接口的简单使用

代码示例：创建一个线程，计算 1 + 2 + 3 + ... + 1000，使用 Callable 实现。

首先，创建一个匿名内部类，并实现 Callable 接口。Callable 是带有泛型参数的，泛型参数就表示返回值的类型。这里的泛型参数用Integer。然后重写 Callable 的 call 方法，完成累加的过程，直接通过返回值返回计算结果。

        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 1000; i++) {
                    sum += i;
                }
                return sum;
            }
        };

当然，由于Callable是一个函数式接口，也可以用lambda表达式的方式来定义：

        Callable<Integer> callable = () -> {
            int sum = 0;
            for (int i = 1; i <= 1000; i++) {
                sum += i;
            }
            return sum;
        };

创建好callable任务后，需要一个线程来启动。

注意，这里并不是在构造Thread时直接将callable传入，而是要先通过FutureTask包装一下，再将FutureTask传入Thread的构造方法。 

Future

Future接口代表一个异步计算的结果，可以在后台线程中进行计算，而不会阻塞当前线程。其中的 get() 方法可以获取这个结果，而且它的调用会阻塞，直到计算完成（类似于 join() ）。如果运行该计算的线程被中断，get() 方法将抛出InterruptedException。如果计算已经完成，那么get 方法立即返回。

FutureTask

执行Callable的一种方法是使用FutureTask，它实现了Future和Runnable接口，所以可以构造一个线程来运行这个任务。

创建线程 t，在线程 t 的构造方法中传入 FutureTask。此时 t 就会执行 FutureTask 内部的 Callable 的 call 方法，完成计算。最终计算结果会存到 futureTask 中。

        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);

如何理解FutureTask？

可以把它理解成吃麻辣烫用到的“小票”。想象去吃麻辣烫，当餐点好后后厨就开始做了，同时前台会给你一张 “小票” 。这个小票就是FutureTask。 它意味着后面我们可以随时凭这张小票去查看自己的这份麻辣烫做出来了没。

最后，在主线程中调用 futureTask.get() ，获取到 FutureTask 中的结果。如何保证主线程中调用 get() 的时候，t 线程已经执行完了呢？由于FutureTask实现了Future接口，因此它的get()方法重写于Future中的get()方法，可以阻塞等待 t 线程的任务完成后，再获取结果。

完整代码

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = () -> {
            int sum = 0;
            for (int i = 1; i <= 1000; i++) {
                sum += i;
            }
            return sum;
        };

        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();

        System.out.println(futureTask.get());
    }
}

三、总结：Callable

1、理解Callable

Callable 和 Runnable 相对，都是描述一个 “任务”。 Callable 描述的是带有返回值的任务，而Runnable 描述的是不带返回值的任务。Callable 通常需要搭配 FutureTask 来使用，FutureTask 用来保存 Callable 的返回结果。因为 Callable 往往是在另一个线程中执行的。执行完成的时间并不确定，FutureTask 就可以负责这个等待结果出来的工作。

2、创建线程的方式汇总

在​​​​​​🔗Thread类及其用法 一文中，曾介绍过几种常见的线程创建的方式。这里将Callable也补充进去：

（1）继承Thread类

通过继承Thread类并重写run()方法来创建一个新线程。

class MyThread extends Thread {
    public void run() {
        // 线程执行的代码逻辑
        System.out.println("Thread running!");
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}

（2）实现Runnable接口（匿名内部类同理）

实现Runnable接口并重写run()方法，然后通过将实现了Runnable接口的对象传递给Thread类的构造方法来创建线程。 

class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的代码逻辑
        System.out.println("Thread running!");
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // 启动线程
    }
}

匿名内部类：

public class Test {
    public static void main(String[] args) {
        // 匿名内部类 Runnable
        // 注意：Runnable实例作为Thread构造器的参数传入
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("i am t!");
            }
        });
 
        t.start();
 
        // main 线程中的方法
        System.out.println("i am main!");
    }
}

（3）使用lambda表达式（最常用）

public class Test {
    public static void main(String[] args) {
        // lambda表达式
        Thread t  = new Thread(() -> {
            System.out.println("i am t!");
        });
 
        t.start();
 
        // main 线程中的方法
        System.out.println("i am main!");
    }
}

（4）实现Callable

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = () -> {
            int sum = 0;
            for (int i = 1; i <= 1000; i++) {
                sum += i;
            }
            return sum;
        };

        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();

        System.out.println(futureTask.get());
    }
}