3

创建线程的两种方式

  1. 直接继承 Thread
  2. 实现 Runnable 接口

这两种方式都有一个缺点:在执行完成任务之后,无法直接获取到最后的执行结果。如果需要获取执行结果,就必须通过共享变量线程通信的方式来达到想要的效果,较为麻烦。

所以从 Java 1.5 起,就提供了两种方式:CallableFuture,通过它们可以在任务执行结束后得到任务执行结果。

Runnable 与 Callable

首先是 java.lang.Rannable,它是一个接口,里面只声明了一个 run() 方法:

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

由于 run() 方法的返回值类型为 void,所以在线程执行完后无任何返回结果。

然后是 java.util.concurrent.Callable,它也是一个接口,也只声明了一个方法,其名为 call()

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

可以看到,这是一个泛型接口,返回的类型就是传进来的 V 类型。

那么,如何使用 Callable 呢?一般是结合 ExecutorService 来使用。ExecutorService 声明了几种 submit 方法,其中有一个就是传入 Callable

<T> Future<T> submit(Callable<T> task);

Future

Future 声明了对具体的 Runnable 或者 Callable 任务执行进行取消、查询、结果获取等方法。必要时可以通过 get 方法获取执行结果,该方法会阻塞直到任务返回结果。

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

由此可见,Future 提供了三种功能:

  1. 取消任务:参数表示是否允许中途取消(中断)
  2. 判断状态:是否已取消、是否已完成
  3. 获取结果:两种方式,指不指定时间

因为 Future 只是一个接口,所以无法直接用来创建对象,因此有了下面的 FutureTask

FutureTask

首先看下 FutureTask 的继承关系:

FutureTask

可以看出 RunnableFuture 继承了 Runnable 接口和 Future 接口,而 FutureTask 实现了 RunnableFuture 接口。所以它既可以作为 Runnable 被线程执行,又可以作为 Future 得到 Callable 的返回值

然后可以看到 FutureTask 内部有这几种状态:

private volatile int state;
private static final int NEW          = 0;
private static final int COMPLETING   = 1;
private static final int NORMAL       = 2;
private static final int EXCEPTIONAL  = 3;
private static final int CANCELLED    = 4;
private static final int INTERRUPTING = 5;
private static final int INTERRUPTED  = 6;

再根据注释,可以得知当创建一个 FutureTask 对象时,初始状态是 NEW,在运行过程中,运行状态仅在方法setsetExceptioncancel 中转换为终端状态。有四种状态转换过程:

  • NEW -> COMPLETING -> NORMAL:正常执行并返回结果(run 执行成功再设置状态为 COMPLETING
  • NEW -> COMPLETING -> EXCEPTIONAL:执行过程中出现异常(setException 先设置状态为 COMPLETING
  • NEW -> CANCELLED:执行前被取消
  • NEW -> INTERRUPTING -> INTERRUPTED:执行时被中断(cancel 参数为 true 才可能出现这个状态)

最后来看下 FutureTask 的两个构造器:

public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}
public FutureTask(Runnable runnable, V result) {
    this.callable = Executors.callable(runnable, result);
    this.state = NEW;       // ensure visibility of callable
}

可知传入的任务最后都是付给内部的 private Callable<V> callable

事实上,FutureTaskFuture 接口的一个唯一实现类。

更多关于 FutureTask 的源码分析,可以看 FutureTask源码解析 这篇文章。

使用示例

Future

第一种方式是使用继承了 ExecutorService 的线程池 ThreadPoolExecutor 中的 submit 方法,将 Callable 直接提交创建 Future

import java.util.concurrent.*;
public class FutureExample {
    static class MyCallable implements Callable<String> {
        @Override
        public String call() throws Exception {
            System.out.println("do something in callable");
            Thread.sleep(5000);
            return "Ok";
        }
    }
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<String> future = executorService.submit(new MyCallable());
        System.out.println("do something in main");
        Thread.sleep(1000);
        String result = future.get();
        System.out.println("result: " + result);
    }
}

FutureTask

第二种方法是创建一个写好 CallableFutureTask 对象实例,再 submit。因为 FutureTask 内部本身拥有 run 方法,也可以直接创建线程 Thread 运行。

利用 ExecutorService

import java.util.concurrent.*
public class FutureTaskWithExecutorService {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask<String> futureTask = new FutureTask<>(() -> { // java 8 函数式写法
            System.out.println("do something in callable");
            Thread.sleep(5000);
            return "Ok";
        });
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.submit(futureTask);
        System.out.println("do something in main");
        Thread.sleep(1000);
        String result = futureTask.get();
        System.out.println("result: " + result);
    }
}

利用 Thread

import java.util.concurrent.*
public class FutureTaskWithThread {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask<String> futureTask = new FutureTask<>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("do something in callable");
                Thread.sleep(5000);
                return "Ok";
            }
        });
        new Thread(futureTask).start();
        System.out.println("do something in main");
        Thread.sleep(1000);
        String result = futureTask.get();
        System.out.println("result: " + result);
    }
}

参考资料

  1. Java并发编程:Callable、Future和FutureTask
  2. FutureTask源码解析

gcusky
135 声望6 粉丝

目标