JavaEE(系列14) -- 多线程(Callable)

Callable接口

Callable 是一个 interface . 相当于把线程封装了一个 "返回值". 方便程序猿借助多线程的方式计算结果.

代码示例: 创建线程计算 1 + 2 + 3 + ... + 1000, 不使用 Callable 版本

思路:

1. 创建一个类Result,包含 sum 表示最终结果, lock 表示线程同步使用的锁对象.
2. main 方法中先创建 Result 实例, 然后创建一个线程 t. 在线程内部计算 1 + 2 + 3 + ... + 1000.
3. 主线程同时使用 wait 等待线程 t 计算结束. (注意, 如果执行到 wait 之前, 线程 t 已经计算完了, 就不必等待了).
4. 当线程 t 计算完毕后, 通过 notify 唤醒主线程, 主线程再打印结果.

static class Result {
  public int sum = 0;
  public Object lock = new Object();
}


public static void main(String[] args) throws InterruptedException {
  Result result = new Result();
  Thread t = new Thread() {
    @Override
    public void run() {
      int sum = 0;
      for (int i = 1; i <= 1000; i++) {
        sum += i;
     }
      synchronized (result.lock) {
        result.sum = sum;
        result.lock.notify();
     }
   }
 };
  t.start();
  synchronized (result.lock) {
    while (result.sum == 0) {
      result.lock.wait();
   }
    System.out.println(result.sum);
 }
}

 可以看到, 上述代码需要一个辅助类 Result, 还需要使用一系列的加锁和 wait notify 操作, 代码复杂, 容易出错.

代码示例: 创建线程计算 1 + 2 + 3 + ... + 1000, 使用 Callable 版本

思路:

• 创建一个匿名内部类, 实现 Callable 接口. Callable 带有泛型参数. 泛型参数表示返回值的类型.
• 重写 Callable 的 call 方法, 完成累加的过程. 直接通过返回值返回计算结果.
• 把 callable 实例使用 FutureTask 包装一下.
• 创建线程, 线程的构造方法传入 FutureTask . 此时新线程就会执行 FutureTask 内部的 Callable 的call 方法, 完成计算. 计算结果就放到了 FutureTask 对象中.
• 在主线程中调用 futureTask.get() 能够阻塞等待新线程计算完毕. 并获取到 FutureTask 中的结果.

package JUC;

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


public class callableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable callable = new Callable() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i < 1000; i++) {
                    sum += i;
                }
                return sum;
            }
        };

        // 需要找一个人,来完成这个任务(需要线程去执行)
        // 在执行之前要进行一个包装,传入线程,启动任务
        FutureTask futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();

        // 获取上面t线程任务的返回值
        System.out.println(futureTask.get());
    }
}

 问题:我们可以发现,我们是在主线程中进行调用的get方法,那么如何保证在调用get之前,call方法就是执行完毕的了呢?

 答案: futureTask 的 get方法和join方法是类似的,都是会堵塞等待的,等待call方法执行完毕,get方法再进行返回call方法的返回值.

 理解Callable和FutureTask

理解 Callable

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

理解 FutureTask 

 

        想象去吃麻辣烫. 当餐点好后, 后厨就开始做了. 同时前台会给你一张 "小票" . 这个小票就是FutureTask. 后面我们可以随时凭这张小票去查看自己的这份麻辣烫做出来了没.