[JUC-06] Callable

1、回顾线程的创建方式

1.1 继承 Thread 类

  线程创建方式一：继承 Thread 类并重写 run 方法。

class MyThread extends Thread{
    @Override
    public void run() {
        while (true) {
            try {
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName()+"--> haha");
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

  调用 start 方法运行线程：

public class ThreadTest {
    public static void main(String[] args) {
        new MyThread().start();
    }
}

1.2 实现 Runnable 接口

  线程创建方式二：实现 Runnable 接口并重写 run 方法，实现类作为 Thread 构造器的参数。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        while (true) {
            try {
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName()+"--> haha");
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

  调用 start 方法运行线程：

public class ThreadTest {
    public static void main(String[] args) {
        new Thread(new MyRunnable()).start();
        new MyThread().start();
    }
}

   传统的是继承 Thread 类和实现 Runnable 接口，JDK5 以后又有实现 Callable 接口和java 的线程池获得 。

2、Callable 定义

  首先看一下 Callable 的源码定义：

package java.util.concurrent;

@FunctionalInterface
public interface Callable<V> {

    V call() throws Exception;
}

  可见， 这是一个函数式接口，因此可以用作 lambda 表达式或方法引用的赋值对象。

3、FutureTask

   通过查看 Thread 构造器，好像只支持 Runnable 接口，并不支持 Callable：

  在 Runnable 中有一个实现了 FutureTask：

  FutureTask 的构造器的参数有 Callable：

  因此，这个 FutureTask 即属于 Runnable ，构造器参数又是 Callable。可以作为 Callable 到 Thread 的桥梁。

  定义一个 Callable 实现类：

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        TimeUnit.SECONDS.sleep(3);
        System.out.println(Thread.currentThread().getName() + "--> MyCallable");
        return "success";
    }
}

  测试：

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

public class ThreadTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<String>(new MyCallable());
        new Thread(futureTask).start();
        String str = futureTask.get();
        System.out.println(str);
    }
}

  运行结果：

  在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 FutureTask 对象在后台完成，当主线程将来需要时，就可以通过 FutureTask 对象获得后台作业的计算结果或者执行状态。

  一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法。一旦计算完成，就不能再重新开始或取消计算。get方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。 只计算一次 get 方法放到最后。