线程创建之Callable+Future+FutureTask

1、前言

 

创建线程有四种方式，分别是实现Runnable接口，继承Thread类，线程池，还有一种就是实现Callable接口。相对于实现Runnable接口和继承Thread类在执行任务后都无法获取执行结果，Callable+Future能够在任务执行结束后得到任务结果。

 

2、Callable和Runnable

 

Runnable是一个接口，只声明了一个run()方法：

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

 

由于run()方法返回值为void类型，所以在执行完任务之后无法返回任何结果。Callable位于java.util.concurrent包下，也是一个接口，也只声明了一个叫做call()的方法

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

 

Callable是一个泛型接口，call()函数返回的类型就是传递进来泛型。

Callable一般情况下是配合ExecutorService来使用的，在ExecutorService接口中声明了若干个submit方法：

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);//该方法不常用
Future<?> submit(Runnable task);

第一个submit方法里面的参数类型就是Callable。一般情况下我们使用第一个submit方法和第三个submit方法，第二个submit方法很少使用。

 

3、Future

 

Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。Future类位于java.util.concurrent包下的一个接口。

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;
}

该接口中声明了五个方法,分别表示：

1、cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。

2、isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。

3、isDone方法表示任务是否已经完成，若任务完成，则返回true；

4、get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；

5、get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。

上述表明Future接口提供了三种功能：1、判断任务是否完成 2、能够中断任务 3、能够获取任务执行结果。

 

 

4、FutureTask

 

Future只是一个接口，无法直接用来创建对象，需要具体实现类FutureTask。FutureTask是Future接口的唯一实现类。

public class FutureTask<V> implements RunnableFuture<V>//FutureTask类实现了RunnableFuture接口，RunnableFuture接口的信息如下：
public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

可以看出RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。所以说明FutureTask既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。类继承图如下：

 

FutureTask除了实现了Future接口外还实现了Runnable接口，因此FutureTask也可以直接提交给Executor执行。 当然也可以调用线程直接执行（FutureTask.run()）。接下来我们根据FutureTask.run()的执行时机来分析其所处的3种状态：

（1）未启动，FutureTask.run()方法还没有被执行之前，FutureTask处于未启动状态，当创建一个FutureTask，而且没有执行FutureTask.run()方法前，这个FutureTask也处于未启动状态。

（2）已启动，FutureTask.run()被执行的过程中，FutureTask处于已启动状态。

（3）已完成，FutureTask.run()方法执行完正常结束，或者被取消或者抛出异常而结束，FutureTask都处于完成状态。

上图是FutureTask的方法执行示意图：

当FutureTask处于未启动或已启动状态时，如果此时我们执行FutureTask.get()方法将导致调用线程阻塞；当FutureTask处于已完成状态时，执行FutureTask.get()方法将导致调用线程立即返回结果或者抛出异常。

当FutureTask处于未启动状态时，执行FutureTask.cancel()方法将导致此任务永远不会执行。当FutureTask处于已启动状态时，执行cancel(true)方法将以中断执行此任务线程的方式来试图停止任务，如果任务取消成功，cancel(...)返回true；但如果执行cancel(false)方法将不会对正在执行的任务线程产生影响(让线程正常执行到完成)，此时cancel(...)返回false。当任务已经完成，执行cancel(...)方法将返回false。

 

Future核心方法：

 

当任务被提交到线程池后，会执行futureTask的run()方法。

public void run() {     // 校验任务状态
        if (state != NEW || !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;　　　　　　　// double check
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {　　　　　　　　　　　//执行业务代码
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {　　　　  // 重置runner
            runner = null;
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }
 

 

这个方法经历了以下几步

1、校验当前任务状态是否为NEW以及runner是否已赋值。这一步是防止任务被取消。

2、double-check任务状态state

3、执行业务逻辑，也就是c.call()方法被执行

4、如果业务逻辑异常，则调用setException方法将异常对象赋给outcome，并且更新state值

5、如果业务正常，则调用set方法将执行结果赋给outcome，并且更新state值

protected void setException(Throwable t) {
    // state状态 NEW->COMPLETING
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = t;
        // COMPLETING -> EXCEPTIONAL 到达稳定状态
        UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL);
        // 一些结束工作
        finishCompletion();
    }
}　
protected void set(V v) {
        // state状态 NEW->COMPLETING
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = v;
            // COMPLETING -> NORMAL 到达稳定状态
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL);
            // 一些结束工作
            finishCompletion();
        }
    }

　

5、应用

 

使用Callable+Future获取执行结果

class CallableTask implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程进行计算");
        Thread.sleep(100);
        int sum = 0;
        for (int i = 0; i < 100 ; i++) {
            sum += i;
        }
        return sum;
    }
}
public class TestFutureTaskDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        CallableTask callableTask = new CallableTask();
        Future<Integer> result = executorService.submit(callableTask);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        System.out.println("主线程在执行任务");
        try {
            System.out.println("task运行结果:"+result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("所有任务执行完毕");
        executorService.shutdown();
    }
}
输出：
子线程进行计算
主线程在执行任务
task运行结果4950
所有任务执行完毕

 

使用Callable+FutureTask获取执行结果

 

 ExecutorService executor = Executors.newCachedThreadPool();
CallableTask task = new CallableTask();
FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
executor.submit(futureTask);

　　

 

 

6、总结

 

实现Runnable接口和实现Callable接口的区别：

 

1、Runnable是自从java1.1就有了，而Callable是1.5之后才加上去的。

2、Callable规定的方法是call(),Runnable规定的方法是run()。

3、Callable的任务执行后可返回值，而Runnable的任务是不能返回值(是void)。

4、call方法可以抛出异常，run方法不可以。

5、运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

6、加入线程池运行，Callable使用submit方法，Runnable一般使用ExecutorService的execute方法（当然也可以用submit）