深入理解Callable

最新推荐文章于 2024-09-29 14:51:50 发布
最新推荐文章于 2024-09-29 14:51:50 发布
阅读量2.7w 收藏 47
点赞数 7
分类专栏： Java并发库源码解析 文章标签： callable future 源码 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19431333/article/details/77483763
版权

概述

Callable和Runnbale一样代表着任务，区别在于Callable有返回值并且可以抛出异常。其使用如下：

public class CallableDemo {

    static class SumTask implements Callable<Long> {

        @Override
        public Long call() throws Exception {

            long sum = 0;
            for (int i = 0; i < 9000; i++) {
                sum += i;
            }

            return sum;
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("Start:" + System.nanoTime());
        FutureTask<Long> futureTask = new FutureTask<Long>(new SumTask());
        Executor executor=Executors.newSingleThreadExecutor();
        executor.execute(futureTask);
        System.out.println(futureTask.get());
        System.out.println("End:" + System.nanoTime());
    }

}

从上面的代码可以看到，使用到了一个FutureTask的变量并且还可以得到Callable执行的结果，那么这个FutureTask是什么呢?

分析

Future接口

Future是一个接口，代表了一个异步计算的结果。接口中的方法用来检查计算是否完成、等待完成和得到计算的结果。当计算完成后，只能通过get()方法得到结果，get方法会阻塞直到结果准备好了。如果想取消，那么调用cancel()方法。其他方法用于确定任务是正常完成还是取消了。一旦计算完成了，那么这个计算就不能被取消。

FutureTask类

FutureTask类实现了RunnableFuture接口，而RunnnableFuture接口继承了Runnable和Future接口，所以说FutureTask是一个提供异步计算的结果的任务。
FutureTask可以用来包装Callable或者Runnbale对象。因为FutureTask实现了Runnable接口，所以FutureTask也可以被提交给Executor（如上面例子那样）。

FutureTask的状态

FutureTask中有一个表示任务状态的int值，初始为NEW。定义如下：

 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;

可能的状态转换包括：

  • NEW -> COMPLETING -> NORMAL
  • NEW -> COMPLETING -> EXCEPTIONAL
  • NEW -> CANCELLED
  • NEW -> INTERRUPTING -> INTERRUPTED

构造方法

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
    }

第一个构造方法好理解；第二个方法是将Runnbale和结果组合成一个Callable，这个可以通过Excutors.callable()方法得出结论：

 public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }
    
static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

从上面可以看到RunnableAdapter实现了Callable并且在call方法中调用了Runnable的run方法，然后将结果返回，这其实就是一个适配器模式啊。
所以说两个构造方法最终都是得到了一个Callable以及设置了初始状态为NEW。

run方法

当将FutureTask提交给Executor后，Executor执行FutureTask时会执行其run方法，下面看一下run方法中做了哪些事情。

public void run() {
        //如果状态不为NEW或者CAS当前执行线程失败，直接返回
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        //尝试调用Callable.call
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    //出现异常了，调用setException方法
                    result = null;
                    ran = false;
                    setException(ex);
                }
                //如果成功了，调用set方法
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            //如果在执行过程，任务被取消了
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

从上面可以看到，任务可以被执行的前提是当前状态为NEW以及CAS当前执行线程成功，也就是runner值，代表执行Callable的线程。从这个看到run方法就是调用Callable的call方法，然后如果出现异常了就调用setException方法，如果成功执行了，那么调用set方法，下面我们分别来看这几种情况。

set方法

当Callable成功执行后，会调用set方法将结果传出。源码如下：

protected void set(V v) {
        //完成NEW->COMPLETING->NORMAL状态转换
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = v;
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
            finishCompletion();
        }
    }

从上面可以看到，将outcome变量赋值为结果，并将state状态更新，最后调用finishCompletion()方法。finishCompletion()方法将移除和通知所有等待线程，这个方法后面再说。下面先看setException方法。

setException方法

setException方法如下：

//完成NEW->COMPLETING->EXCEPTIONAL状态转换
protected void setException(Throwable t) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = t;
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }

从上面看到，该方法和set方法类似，完成状态转换，将结果设置为Throwable并调用finishCompletion通知和移除等待线程。

get方法

当想得到FutureTask的结算结果时，调用get方法，get方法可以允许多个线程调用，下面的例子展示了多个线程调用get的情况。

 public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("Start:" + System.nanoTime());
        FutureTask<Long> futureTask = new FutureTask<Long>(new SumTask());
        Executor executor=Executors.newSingleThreadExecutor();
        executor.execute(futureTask);
        for(int i=0;i<5;i++){
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("get result "+futureTask.get());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (ExecutionException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        System.out.println(futureTask.get());
        System.out.println("End:" + System.nanoTime());
    }

该例子展示了一共有5个线程想得到FutureTask的结果，一旦调用get，那么该线程就会阻塞。
FutureTask的get方法实现如下：

 public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }

从上面的代码可以看到，如果当前任务的状态不大于COMPLETING，那么会调用awaitDone方法，这个方法会将调用的线程挂起；否则直接调用report方法返回结果。
在前面set和setException方法中可以得出结论：当状态从NEW变为COMPLETING后，才会将outcome赋值，也就是状态是NEW或者COMPLETING时，outcome都还未赋值，也就意味着计算仍在进行，那么此时想要get到结果，就必须等待。下面先看下awaitDone方法是如何将调用线程阻塞的。awaitDone的两个参数分别表示是否定时，以及定时的时间多少。get的另一个重载方法就提供了超时限制。awaitDone方法如下：

private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        WaitNode q = null;
        boolean queued = false;
        for (;;) {
            //如果当前线程被中断了，移除并抛出异常
            if (Thread.interrupted()) {
                removeWaiter(q);
                throw new InterruptedException();
            }

            int s = state;
            //如果状态大于COMPLETING，说明已经计算已经完成了
            if (s > COMPLETING) {
                if (q != null)
                    q.thread = null;
                return s;
            }
            //状态是COMPLETING，在set和setException方法中可以看到处于该状态马上就会进入下一个状态
            else if (s == COMPLETING) // cannot time out yet
                Thread.yield();
            //新建一个等待节点
            else if (q == null)
                q = new WaitNode();
            //还没有入队，尝试入队
            else if (!queued)
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                     q.next = waiters, q);
            //如果限制了时间
            else if (timed) {
                nanos = deadline - System.nanoTime();
                if (nanos <= 0L) {
                    removeWaiter(q);
                    return state;
                }
                //挂起指定时间
                LockSupport.parkNanos(this, nanos);
            }
            //无限挂起
            else
                LockSupport.park(this);
        }
    }

上面的代码中有一个WaitNode类，该类表示等待节点，保存等待的线程以及下一个节点，是一个单链表结构，其定义如下:

 static final class WaitNode {
        volatile Thread thread;
        volatile WaitNode next;
        WaitNode() { thread = Thread.currentThread(); }
    }

awaitDone方法中进入死循环后，主要有几步：

  1. 如果线程被中断了，移除节点，抛出异常
  2. 如果状态大于COMPLETING，那么直接返回
  3. 如果状态是COMPLETING，在set和setException可以看到，处于COMPLETING是一个暂时状态，很快就会进入下一个状态，所以这儿就调用了Thread.yield()方法让步一下
  4. 如果状态是NEW且节点为null，那么创建一个节点
  5. 如果还没有将当前线程加入队列，那么将当前线程加入到等待队列中。由于WaitNode是一个单链表结构，FutureTask中保存了waiters的变量，就可以沿着该变量得到所有等待的线程
  6. 如果限制了时间，那么计算出生出超出时间，挂起指定时间。当解除挂起时，如果计算还未完成，那么将会由于没有时间了，调用removeWaiter方法移除节点。
  7. 如果没有限制时间，那么将线程无限挂起

上面几种情况下，都涉及了移除节点，removeWaiter方法就是删除单链表中一个节点的实现。
当线程被解除挂起，或计算已经完成后，将会get方法中将会调用report返回结果，其实现如下：

 private V report(int s) throws ExecutionException {
        Object x = outcome;
        //如果计算正常结束
        if (s == NORMAL)
            return (V)x;
        //如果计算被取消了
        if (s >= CANCELLED)
            throw new CancellationException();
        //如果计算以异常计算
        throw new ExecutionException((Throwable)x);
    }

从上面可以看到report会根据任务的状态不同返回不同的结果。

  • 如果计算正常结束，即状态是NORMAL，那么返回正确的计算结果
  • 如果计算被取消了，即状态大于等于CANCELLED，那么抛出CancellationException
  • 如果计算以异常结束，即状态是EXCEPTIONAL，那么抛出ExecutionException

finishCompletion方法

在set方法和setException方法中，当将结果赋值后，都调用了finishCompletion方法来移除和通知等待线程。由于get方法中可以挂起了一群等待节点，那么当结果被计算出来了，自然应该通知那些等待线程。finishCompletion的实现如下：

 private void finishCompletion() {
        //如果有等待线程，从头开始解除挂起
        for (WaitNode q; (q = waiters) != null;) {
            if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
                for (;;) {
                    //得到等待节点的线程，解除挂起
                    Thread t = q.thread;
                    if (t != null) {
                        q.thread = null;
                        LockSupport.unpark(t);
                    }
                    WaitNode next = q.next;
                    if (next == null)
                        break;
                    q.next = null; // unlink to help gc
                    q = next;
                }
                break;
            }
        }
        
        done();

        callable = null;        // to reduce footprint
    }

finishCompletion的实现比较简单，就是遍历等待线程的单链表，释放那些等待线程。当线程被释放后，那么在awaitDone的死循环中就会进入下一个循环，由于状态已经变成了NORMAL或者EXCEPTIONAL，将会直接跳出循环。
释放了所有线程后，将会调用done()方法，FutureTask的done()方法默认没有任何实现，子类可以在该方法中调用完成回调以及记录操作等等。
上面的方法分析完了FutureTask的主要流程，包括调用get线程的阻塞、run方法执行、计算结果的返回。下面再来看一些取消、查看状态的方法。

cancel方法

cancel方法用于取消Callable的计算。参数mayInterruptIfRunning指明是否应该中断正在运行的任务，返回值表示取消是否成功了。其源码如下：

 public boolean cancel(boolean mayInterruptIfRunning) {
        if (!(state == NEW &&
              UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
                  mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
            return false;
        try { 
            //如果需要中断
            if (mayInterruptIfRunning) {
                try {
                    Thread t = runner;
                    if (t != null)
                        t.interrupt();
                } finally {
                    //最终状态INTERRUPTED
                    UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
                }
            }
        } finally {
            //释放等待线程
            finishCompletion();
        }
        return true;
    }

从上面可以看到如果是需要中断正在执行的任务，那么状态转换将会是NEW->INTERRPUTING->INTERRUPTED；如果不需要中断正在执行的任务，那么状态转换将会是NEW->CANCELD。不管是否中断，最终都会调用finishCompletion()完成对等待线程的释放。
当这些线程释放后，再进入到awaitDone中的循环时，返回的状态将会是大于等于CANCELD，在report方法中将会得到CancellationException异常。

isDone方法

Future接口中isDone方法表明任务是否已经完成了，如果完成了，那么返回true，否则false。下面是FutureTask的实现：

 public boolean isDone() {
        return state != NEW;
    }

可以看到只要状态从初始状态NEW完成了一次转换，那么就说明任务已经被完成了。

总结

Callable是一种可以返回结果的任务，这是它与Runnable的区别，但是通过适配器模式可以使Runnable与Callable类似。Future代表了一个异步的计算，可以从中得到计算结果、查看计算状态，其实现FutureTask可以被提交给Executor执行，多个线程可以从中得到计算结果。Callable和Future是配合使用的，当从Future中get结果时，如果结果还没被计算出来，那么线程将会被挂起，FutureTak内部使用一个单链表维持等待的线程；当计算结果出来后，将会对等待线程解除挂起，等待线程就都可以得到计算结果了。

关注我的技术公众号，不定期会有优质技术文章推送。

微信扫一扫下方二维码即可关注：
微信公众号二维码

xingfeng_coder
关注
专栏目录
实现Callable接口
sunqianLOL的博客
06-23 218
实现Callable接口 package com.sq.java2; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; /** * 创建线程的方式三：实现Callable接口。 --- JDK 5.0 新增 * * 如何理解实现 Callable 接口的方式创建多线程比实现 Runnable 接口创
【高并发】深入解析Callable接口
m0_59595915的博客
02-16 329
本文纯干货，从源码角度深入解析Callable接口，希望大家踏下心来，打开你的IDE，跟着文章看源码，相信你一定收获不小。 1.Callable接口介绍 Callable接口是JDK1.5新增的泛型接口，在JDK1.8中，被声明为函数式接口，如下所示。 @FunctionalInterface public interface Callable<V> { V call() throws Exception; } 复制代码 在JDK 1.8中只声明有一个方法的接口为函数式接口，函
Callable接口
weixin_45417821的博客
07-19 1782
文章目录Callable概述Future 接口FutureTask使用 Callable 和 Future小结(重点) Callable概述 目前我们学习了有两种创建线程的方法-一种是通过创建 Thread 类，另一种是通过使用 Runnable 创建线程。但是，Runnable 缺少的一项功能是，当线程终止时（即 run（）完成时），我们无法使线程返回结果。为了支持此功能，Java 中提供了 Callable 接口。 现在我们学习的是创建线程的第三种方案—Callable 接口 编写如下代码，发现报错。
Callable类型注解详解：定义函数参数和返回值类型的方法
最新发布
慕漓的博客
09-29 812
Callable是Python的类型注解模块typing中的一部分，它用于表示可以被调用的对象，包括函数和方法。使用Callable，我们可以定义一个函数的签名，包括参数类型和返回类型。让我们通过一个简单的示例来说明Callable的使用。print(result) # 输出: [1, 4, 9, 16]在这个示例中，函数接受一个列表和一个函数作为参数。通过使用，我们清晰地表明了func的参数类型和返回类型。有时候，我们需要定义更复杂的函数签名。print(result) # 输出: (15, 15)
Java线程深入：Callable与FutureTask，线程池解析
Java线程的使用涉及到多方面的技巧和策略，理解并熟练掌握Callable、Future、线程创建方式以及线程池的运用，对于优化并发程序的性能和可维护性至关重要。在实际开发中，合理利用线程池可以极大地提高系统的并发能力...
Python callable内置函数原理解析
09-17
了解`callable()`的原理和使用对于深入理解Python对象行为至关重要。接下来，我们将详细讨论`callable()`的工作方式、应用场景及其相关知识点。 一、`callable()`函数简介 `callable()`函数的基本语法是 `callable...
Java高级特性：深入理解多线程与Callable使用
资源摘要信息:"Java多线程基础（1）使用线程" ...总结来说，Java多线程编程是Java语言的核心特性之一，了解并掌握如何创建线程以及如何使用Callable和Future创建线程对于开发高效、响应式的Java应用程序至关重要。
Java多线程Callable接口
01-20
Runnable是执行工作的独立任务，但是它不返回任何值，如果你希望任务在完成时能够返回一个值，那么可以实现Callable接口而不是Runnable接口。在Java SE5中引入的Callable是一种具有类型参数的泛型，它的类型参数表示的是从方法call()中返回的值，并且必须使用ExecutorService.submit()方法调用它。 import java.util.ArrayList; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import j
Callable 接口
qq_56444564的博客
02-12 405
Callable 是一个 interface . 相当于把线程封装了一个 "返回值". 方便程序猿借助多线程的方式计算结果.结果.Callable 和 Runnable 相对, 都是描述一个 "任务". Callable 描述的是带有返回值的任务,Callable 和 Runnable 相对, 都是描述一个 "任务". Callable 描述的是带有返回值的任务,Callable 是一个 interface . 相当于把线程封装了一个 "返回值". 方便程序猿借助多线程的方式计算。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值