FutureTask源码解读——阻塞获取异步计算结果（阻塞、取消、装饰器、适配器、Callable）

置顶 已于 2022-04-02 10:21:15 修改
阅读量864 收藏 5
点赞数 2
分类专栏： JUC源码解读 文章标签： FutureTask 异步get 取消任务 JUC JDK8
于 2020-11-15 21:29:04 首次发布
本文为博主原创文章，转载请注明本人源链接。微信公众号搜索：徐同学呀，愿与你共同进步！
本文链接：https://blog.csdn.net/weixin_36586120/article/details/109710144
版权

天青色等烟雨，而我在等你，微信公众号搜索：徐同学呀，持续更新肝货，快来关注我，和我一起学习吧~

更多JUC源码解读系列文章请持续关注JUC源码解读文章目录JDK8！

文章目录

一、前言

FutureTask继承自Runnable，所以也可以实现异步执行的效果，但是和常规的异步执行方式不同，常规异步只要求异步的过程是正确的就可以了，而FutureTask不仅可以知道异步执行的状态，还可以知道异步结果。那它是如何实现的呢？

FutureTask在JUC中是一个比较重要的类：

  • 它是ScheduledThreadPoolExecutor内部类ScheduledFutureTask的父类，ScheduledThreadPoolExecutor实现延迟和周期性调度功能时调用的就是FutureTask的函数。
  • 再者线程池的抽象父类AbstractExecutorService中有一个函数submit()，也是可以提交任务异步执行，其内部通过将任务类包装成FutureTask提交给工作线程异步执行，更是被“面试圣经”总结为是第三种实现线程的方式。这种说法是肤浅的，感知肤浅正是探索底层的开始。
//AbstractExecutorService#submit
public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
}

二、原理简述

FutureTask作为Runnable的子类，它就像是一个装饰器在Runnable异步执行的功能上，又增加了可以获取异步执行状态以及结果的功能：

  • 其内部维护了一个Callable类型的成员变量，任务代码会包装成callable，FutureTask直接调用Callable.call()执行任务代码并返回结果。
  • 还维护了一个链表实现的栈，外部获取结果的线程在任务没有执行完前都会被压入栈并阻塞（awaitDone），任务完成唤醒所有阻塞线程（finishCompletion）。

三、基本结构

FutureTask实现了接口RunnableFuture，RunnableFuture继承了接口Runnable和Future。
futureTask

1、基本定义

FutureTask有7个状态：NEW（新建）、COMPLETING（正在完成）、NORMAL（正常完成）、EXCEPTIONAL（异常完成）、CANCELLED（被取消）、INTERRUPTING（正在中断）、INTERRUPTED（被中断）。如下是状态流转：

  • NEW -> COMPLETING ：此时get会被阻塞，并将当前线程放入阻塞栈中。
  • NEW -> COMPLETING -> NORMAL ：此时outcome是callable的运行结果。
  • NEW -> COMPLETING -> EXCEPTIONAL ：此时outcome是callable的运行异常。
  • NEW -> CANCELLED ：调用了cancel(false)取消任务，删除并唤醒所有等待的线程。
  • NEW -> INTERRUPTING -> INTERRUPTED ：调用了cancel(true)中断任务，删除并唤醒所有等待的线程。

FutureTask的两大特点阻塞和取消：

  • 阻塞是由waiters属性实现，它是一个由链表实现的栈，先进后出。
  • 取消是由runner属性实现，runner以CAS的方式记录当前运行线程，运行完成会再次设置为null，运行过程中取消，将调用runner.interrupt()中断运行线程，在线程池中取消是中断工作线程。
public class FutureTask<V> implements RunnableFuture<V> {
    
    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;

    /** The underlying callable; nulled out after running */
    //底层调用的任务
    private Callable<V> callable;
    /** The result to return or exception to throw from get() */
    private Object outcome; // non-volatile, protected by state reads/writes
    //记录当前计算线程，用于取消时，中断计算。
    private volatile Thread runner;
    /** Treiber stack of waiting threads */
    //等待栈
    private volatile WaitNode waiters;
}

2、构造函数

构造函数有两种，一种参数类型是Callable，可直接赋值给成员变量callable；另一种参数类型是Runnable，并可传入一个result，不过没什么用。

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) {
    //设置进来的runnable 会被适配成callable（RunnableAdapter）
    this.callable = Executors.callable(runnable, result);
    this.state = NEW;       // ensure visibility of callable
}

Runnable会被包装成一个实现了Callable的RunnableAdapter赋值给callable。适配的过程也可以看出result是怎么传进去就会怎么返回。

//Executors
public static <T> Callable<T> callable(Runnable task, T result) {
    if (task == null)
        throw new NullPointerException();
    //将Runnable适配成Callable
    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();
            //传入的result并没有做任何处理
            return result;
        }
}

所以官方给的函数AbstractExecutorService#submit(java.lang.Runnable, T)，也可以传入Runnable类型的任务和result，不过只能判断任务是否完成或者取消任务，外部get的result还是传进去的result，没有太大的意义。

3、核心函数

（1）get阻塞获取结果

get()有两种，一种是会等待计算结束返回，一种是加了超时时长timeout，get线程等待timeout时长，如果此时还没有完成就抛出异常TimeoutException。

/**
 * 会一直阻塞到计算结束，可以被打断
 * @throws CancellationException {@inheritDoc}
 */
public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
        //运行未完成，放入等待栈中
        s = awaitDone(false, 0L);
    return report(s);
}

public V get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException {
    if (unit == null)
        throw new NullPointerException();
    int s = state;
    if (s <= COMPLETING &&
        (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
        //阻塞时间到，若还没有完成就抛异常
        throw new TimeoutException();
    return report(s);
}

private V report(int s) throws ExecutionException {
    Object x = outcome;
    if (s == NORMAL)
        //如果是正常结束，返回结果
        return (V)x;
    //取消或者中断的就抛出取消异常
    if (s >= CANCELLED)
        throw new CancellationException();
    //其他状态的抛异常EXCEPTIONAL
    throw new ExecutionException((Throwable)x);
}
awaitDone阻塞等待

阻塞的核心代码就是awaitDone，get时若正在计算，将会被放入等待栈阻塞，直到超时时间到，或者被唤醒，或者被中断，然后返回当前的状态。

  1. 当前get线程被打断，删除等待节点，并抛出InterruptedException。
  2. 若此时s > COMPLETING有可能完成、取消、中断，将等待节点（WaitNode）的thread设置为null，并返回当前状态。
  3. 若s == COMPLETING说明正在完成，暂停当前get线程，让出对cpu的占用，执行其他get线程。
  4. 若当前get线程还没有入等待栈，实例化一个WaitNode，并cas入栈。
  5. 最后阻塞，阻塞分为时间阻塞和永久阻塞，阻塞时间到，删除等待节点并返回当前状态。
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;
        if (s > COMPLETING) {
            //完成，取消，中断
            if (q != null)
                q.thread = null;
            //返回结果状态
            return s;
        }
        else if (s == COMPLETING) // cannot time out yet
            //正在完成，暂停当前线程，执行其他get线程
            Thread.yield();
        else if (q == null)
            //NEW 状态，新建一个WaitNode
            q = new WaitNode();
        else if (!queued)
            //cas入栈
            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
            //timed false  会一直阻塞到 计算完成， 需要唤醒
            LockSupport.park(this);
    }
}

/**
 * 栈，node.thread=null的节点会被删除
 * @param node
 */
private void removeWaiter(WaitNode node) {
    if (node != null) {
        node.thread = null;
        retry:
        for (;;) {
            // restart on removeWaiter race
            //循环删除node.thread = null的节点
            for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
                s = q.next;
                if (q.thread != null)
                    pred = q;
                else if (pred != null) {
                    pred.next = s;
                    if (pred.thread == null) // check for race
                        continue retry;
                }
                else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                      q, s))
                    continue retry;
            }
            break;
        }
    }
}
（2）cancel取消任务中断工作线程

调用cancel()可能是被中断（mayInterruptIfRunning=true）或者是主动取消（mayInterruptIfRunning=false）。

  • 中断取消，设置state为INTERRUPTING，并调用runner.interrupt()中断当前运行线程，设置state为INTERRUPTED，最后清空等待栈中所有阻塞节点并唤醒所有等待的线程。
  • 主动取消，设置state为CANCELLED，最后清空等待栈中所有阻塞节点并唤醒所有等待的线程。

从代码可以看出只有state为NEW才能被取消。

public boolean cancel(boolean mayInterruptIfRunning) {
    if (!(state == NEW &&
            //cass设置 state为INTERRUPTING or CANCELLED
          UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
              mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
        //状态没有修改成功返回false，取消失败
        return false;
    try {    // in case call to interrupt throws exception
        //如果是被打断的  就调用t.interrupt();中断线程
        if (mayInterruptIfRunning) {
            try {
                Thread t = runner;
                if (t != null)
                    //中断当前线程
                    t.interrupt();
            } finally { // final state
                //设置state为中断
                UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
            }
        }
    } finally {
        //最后  删除并唤醒所有等待的线程
        finishCompletion();
    }
    return true;
}
//删除并唤醒所有等待的线程
private void finishCompletion() {
    // assert state > COMPLETING;
    for (WaitNode q; (q = waiters) != null;) {
        //循环cas WaitNode 为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
                    break;
                q.next = null; // unlink to help gc 设置为null  有利于gc
                q = next;
            }
            break;
        }
    }
    //钩子函数
    done();
    callable = null;        // to reduce footprint
}
（3）run执行任务代码并唤醒所有等待线程

FutureTask是会被传给ThreadPoolExecutor.Worker，由线程池启动工作线程，然后调用FutureTask的run()函数，run()又调用callable.call()。run（）会将结果设置给outcome。

public void run() {
    //新任务-->执行UNSAFE.compareAndSwapObject(this, runnerOffset,
    //                                         null, Thread.currentThread()))
    //新任务会将当前线程设置给runner 这里的作用是乐观锁，保证下面的执行流程是只有一个线程
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                //调用callable的call，并设置返回值
                //如果传进来的任务是Runnable，会被转换成callable
                result = c.call();
                //若运行异常,ran=false，异常会被捕获处理
                //所以传进来的任务的run或者call代码块最好try-catch下
                ran = true;
            } catch (Throwable ex) {
                result = null;
                ran = false;
                //设置异常给outcome
                setException(ex);
            }
            if (ran)
                //运行正常完成，设置结果给outcome
                set(result);
        }
    } finally {
        // runner must be non-null until state is settled to
        // prevent concurrent calls to run()
        //最后 runner=null 相当于是释放锁
        runner = null;
        // state must be re-read after nulling runner to prevent
        // leaked interrupts
        int s = state;
        if (s >= INTERRUPTING)
            //如果状态是被打断,让出cpu
            handlePossibleCancellationInterrupt(s);
    }
}

执行细节如下：

  • 新任务CAS设置当前线程给runner，这里的作用是乐观锁保证下面的执行流程只有一个线程，并且外部可以通过runner随时中断执行。
  • 直接调用callable.call()执行任务代码。
  • 中途出现异常，将异常设置给outcome，状态流转为异常完成，并唤醒所有等待的线程。
protected void setException(Throwable t) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        //设置异常
        outcome = t;
        //设置异常状态
        UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
        //唤醒所有线程
        finishCompletion();
    }
}
  • 正常运行完毕将运行结果result设置给outcome，状态流转为正常完成，并唤醒所有等待的线程。
protected void set(V v) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        //设置为完成状态
        outcome = v;
        //设置正常状态
        UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
        //完成操作-删除并唤醒所有等待的线程
        finishCompletion();
    }
}

private void finishCompletion() {
    // assert state > COMPLETING;
    for (WaitNode q; (q = waiters) != null;) {
        //循环cas WaitNode 为null，删除所有等待的线程
        //这里cas删除 其实是为了if里面的操作线程安全无锁
        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
                    break;
                q.next = null; // unlink to help gc 设置为null  有利于gc
                q = next;
            }
            break;
        }
    }
    //钩子函数
    done();

    callable = null;        // to reduce footprint
}
  • 最终runner设置为null，相当于释放锁；如若此时状态为被打断状态INTERRUPTING，需要让出cpu。
private void handlePossibleCancellationInterrupt(int s) {
    // It is possible for our interrupter to stall before getting a
    // chance to interrupt us.  Let's spin-wait patiently.
    if (s == INTERRUPTING)
        while (state == INTERRUPTING)
            //暂停当前线程，让出cpu时间片
            Thread.yield(); // wait out pending interrupt
}
（4）runAndReset重复执行

runAndReset()和run()类似，但是没有把result设置给outcome，函数返回为boolean，用于是否重复执行。

protected boolean runAndReset() {
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return false;
    boolean ran = false;
    int s = state;
    try {
        Callable<V> c = callable;
        if (c != null && s == NEW) {
            try {
                c.call(); // don't set result
                //如果c.call抛异常，将会被处理，但是没有打印堆栈，使用者不易排查
                //不会再往下执行ran=false
                //所以传进来的任务run里需要自己try-catch
                ran = true;
            } catch (Throwable ex) {
                //设置异常给outcome
                setException(ex);
            }
        }
    } 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
        s = state;
        if (s >= INTERRUPTING)
            //如果状态是被打断,让出cpu
            handlePossibleCancellationInterrupt(s);
    }
    return ran && s == NEW;
}
（5）无锁化

FutureTask的几个成员变量并没有使用悲观锁Lock或者synchronized，而是用了cas乐观锁，而且也用了volatile修饰，使得state的流转，runner的设置，waiters的入栈出栈线程安全。

private static final sun.misc.Unsafe UNSAFE;
private static final long stateOffset;
private static final long runnerOffset;
private static final long waitersOffset;
static {
    try {
        //这不就是乐观锁吗 无锁化-牛逼
        UNSAFE = sun.misc.Unsafe.getUnsafe();
        Class<?> k = FutureTask.class;
        stateOffset = UNSAFE.objectFieldOffset
            (k.getDeclaredField("state"));
        runnerOffset = UNSAFE.objectFieldOffset
            (k.getDeclaredField("runner"));
        waitersOffset = UNSAFE.objectFieldOffset
            (k.getDeclaredField("waiters"));
    } catch (Exception e) {
        throw new Error(e);
    }
}

四、实际应用

FutureTask可以配合线程池使用，也可以单独启动线程。

（1）配合线程池使用。

LinkedBlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();
ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 5,
        30, TimeUnit.SECONDS, workQueue);
Future<Integer> future = poolExecutor.submit(new Callable<Integer>() {
    @Override
    public Integer call() throws Exception {
        int i = 100;
        int j = 100;
        int sum = i + j;
        Thread.sleep(2000);
        return sum;
    }
});
long s = System.currentTimeMillis();
//获得计算结果
Integer result = future.get();
long e = System.currentTimeMillis();
System.out.println("result=" + result + ",ms=" + (e-s));
//result=200,ms=2016

（2）单独启动线程

List<FutureTask> taskList = new ArrayList<FutureTask>();
for (int i = 0; i < 3; i++) {
    int j = i;
    FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
            return j + 10;
        }
    });
    Thread thread = new Thread(futureTask);
    thread.start();
    taskList.add(futureTask);
}
//批量获取结果
for (FutureTask futureTask : taskList) {
    System.out.println(futureTask.get());
}

需要注意：

无论是线程池submit提交任务还是批量启动多个线程使用FutureTask，切不可在一个for循环里一边异步执行一边获取结果，这样会使得整个过程因为阻塞获取结果变成单线程。

应该批量提交任务，批量获取结果。

五、总结

  1. FutureTask的特点异步执行、阻塞获取结果、可取消。
  2. FutureTask运用了装饰器和适配器模式。装饰器的体现是在Runnable异步执行的基础上增加了异步阻塞获取结果和取消的功能；适配器的体现是当传入的是任务是Runnable类型时会被适配成一个实现了Callable的RunnableAdapter。
  3. callable是FutureTask的成员变量，无法单独实现线程，配合FutureTask使用最佳。
  4. 任务正常完成outcome的值是callable.run的运行结果；任务异常完成outcome是异常。
  5. 成员变量runner的作用，可在外围中断取消正在执行的任务，也有保证任务执行线程安全。
  6. 成员变量waiters，get获取结果当未完成前一个个入栈阻塞，完成时全部出栈唤醒。
  7. 因为run和runAndReset对异常不作为，建议任务代码自行try-catch。

PS: 如若文章中有错误理解，欢迎批评指正，同时非常期待你的评论、点赞和收藏。我是徐同学，愿与你共同进步！

【java】java 多线程 异步计算 FutureTask 源码详解
九师兄
03-19 1121
FutureTask 为 Future 提供了基础实现，如获取任务执行结果(get)和取消任务(cancel)等。如果任务尚未完成，获取任务执行结果时将会阻塞。一旦执行结束，任务就不能被重启或取消(除非使用runAndReset执行计算)。FutureTask 常用来封装 Callable 和 Runnable，也可以作为一个任务提交到线程池中执行。除了作为一个独立的类之外，此类也提供了一些功能性函数供我们创建自定义 task 类使用。FutureTask 的线程安全由CAS来保证。
Java多线程系列--掌握Future，轻松获取异步任务结果
leobert.lan的博客
09-26 1467
连这些读不知道的话，面试肯定要挂了。 今天，我们一同回顾：多线程中并发和异步的基础中的基础，掌握了它们才有面试及格的可能。
【Java并发编程】FutureTask 阻塞等待异步结果
HaYa
09-10 2059
什么是FutureTask FutureTask类实现了RunnableFuture接口，RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。所以FutureTask 既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。 怎么用FutureTask 由介绍可知，FutureTa...
FutureTask源码解读——阻塞获取异步计算结果（阻塞、取消、装饰器
最新发布
2401_84412648的博客
04-20 533
我还通过一些渠道整理了一些大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。还有专门针对JVM、SPringBoot、SpringCloud、数据库、Linux、缓存、消息中间件、源码等相关面试题。网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
FutureTask 从源码分析为什么会线程阻塞
guo_xl的专栏
03-18 2483
FutureTask 继承关系如下 public FutureTask&amp;amp;amp;lt;V&amp;amp;amp;gt; implements RunnableFuture&amp;amp;amp;lt;V&amp;amp;amp;gt; { public FutureTask(Callable&amp;amp;amp;lt;V&amp;amp;amp;gt; callable) { if (calla
切记【阻塞/非阻塞】【FutureTask异步执行】
10-28 1233
一、阻塞非阻塞 1.1 同步阻塞IO 在Java应用中，默认情况下所有的Socket连接的IO都是同步阻塞的 例如在java发起的一个socket的read操作大致流程如下： 1.Java启动io的read读操作开始，用户线程就进入阻塞状态 2.系统接收到read调用，开始准备数据，如果内核数据没有准备好，则内核进行等待。 3.内核一直等待完整的数据到达，就会将数据从内核缓冲区复制到用户缓冲区，返回内核结果. 4.内核返会结果后，用户线程才会解除阻塞的状态，重新运行。 特点：在内核执行IO两个点阶段，用户线
重回基础----FutureTask解析（为何get方法获取会阻塞）
CUITCUIT1的博客
07-27 1938
当我们在线程池中执行一个 Callable 方法时，其实是将 Callable 任务封装成一个 RunnableFuture 对象去执行，同时将这个 RunnableFuture 对象返回，这样我们就拿到了 FutureTask 的引用，可以随时获取到任务执行的状态，并且可以在任务执行完成后通过该对象获取执行结果。我们主要看下 awaitDone 方法的执行逻辑。由此可以知道，我们将一个 FutureTask 任务 submit 到线程池中执行的时候，如果发生了异常，是会在调用 get 方法的时候抛出的。
FutureTask源码解析
FutureTask的主要作用是在多线程环境下，进行任务的异步执行和结果的获取。 ### 1.2 FutureTask应用场景 FutureTask通常应用于以下两个场景： - 需要一个异步执行的任务，并且在任务执行完成后需要获取任务的执行...
Java并发编程(二十)：FutureTask源码分析
黄智霖的博客
05-11 2868
使用 FutureTask<String> futureTask = new FutureTask(() -> "success"); new Thread(futureTask).start(); futureTask.get(); 源码分析 FutureTask提供了两个构造方法，分别是传入一个Callable，和传入一个Runnable和返回值result。如果传入的是Runnable和返回值，那么会通过适配器RunnableAdap
【并发进阶】Future掌控未来之Callable跨线程返回结果和抛出异常的原理分析
chenxuyuana的博客
07-07 1147
我们知道线程的发起Thread.start() 实质上是，start()调用native方法 start0(), 然后唤起系统线程，在系统线程中回调 Runnable中的run()方法。而且整个过程是异步的，导致在Runnable的两个致命缺陷，第一个是不能返回结果，第二个是不能抛出异常。所以Java爸爸后来引入了Callable这个接口，这个接口旨在解决这两个缺陷。至于怎么用Callable, 相信都已经轻车熟路了，作为一个高级程序员只知道怎么用是不够的，我们还需要知道为什么？那么我们先思考下面几个问题：
手写Callable、FutureTask实现主线程阻塞，获取异步线程的执行结果
jack__love的博客
10-20 742
手写Callable、FutureTask实现主线程阻塞，获取异步线程的执行结果
多线程实际使用（代码演示） FutureTask 阻塞队列 LinkedBlockingDeque
AdamCafe的博客
02-19 282
1.多个服务接口如何同时调用 京东个人信息业务，设计多种信息，需要调用多个接口 。 多个服务接口应该同时调用，串行的话时间太长。 这面的代码有弊端。get（）拿返回值可能会造成web服务器阻塞 解决方案：web服务器只接受request，启动子线程去执行。 代码如何实现： 如果请求用户量大时：可能依然存在问题（压力到后端服务器） 解决方案：后端服务提供批量查询 实际代码演示：模拟1w个请求去查询 单次调用 性能低下： 使用批量调用： 先定义个线程池 ...
Java多线程-FutureTask的get方法阻塞问题
热门推荐
Leetp
04-27 2万+
FutureTask类中get方法阻塞的问题： get方法的实现： /** * @throws CancellationException {@inheritDoc} */ public V get() throws InterruptedException, ExecutionException { int s = state;
通过FutureTask来实现阻塞当前线程等待其他线程处理的结果
Kalwang的博客
07-21 3912
最近在开发中遇到一个这样的需求，如：定义一个接口给第三方调用，方法返回的结果需要通过异步任务返回。我们可以利用FutureTask很轻松的实现，还是直接上代码吧。先自定义一个FutureTask：private static class PassFuture<V> extends FutureTask<V> { public PassFuture() { sup
java future get阻塞_由FutureTask的get方法靠什么机制来阻塞引发的思考
weixin_31225753的博客
02-19 3070
1. FutureTask的get方法靠什么机制来阻塞看其get方法源码：/***@throwsCancellationException {@inheritDoc}*/public V get() throwsInterruptedException, ExecutionException {returnsync.innerGet();}不难发现，FutureTask是依靠其内部类java.ut...
Python - 装饰器(Decorator) - 可调用的(Callable)
zbbfb2001的博客
07-08 604
其实这个是个大家都已比较熟悉的话题，Callable，也就是可调用的。但当接触到装饰器(decorator)的时候，表现形式复杂些时，我发现还是有必要理清一下的。 什么是Callable 任何可以使用括号操作符的目标都是可调用的。 如果我们在Python使用某个目标具有以下特点，我们就说这个目标是可调用的。 目标名 在Python中目标名往往都是绑定某个目标的内存地址。我们就是通过目标名最终引用到目标本身。 括号 当标签名后面跟着括号时，那就是说有代码被执行了 输入和输出 输入：也就实参，在
适配器模式之FutureTask
wuraox的博客
09-08 460
最近在学习JUC的相关类的源码的时候，看到了FutrueTask类中有使用到适配器模式，加之前段时间刚学习了设计模式，所以就了解了一下加深对适配器模式的理解。 简单解释一下适配器的思想：就是一个类不能被直接使用，就通过适配器将其转换为另一个类的过程。就像家庭电压为220V，但是手机充电是不能直接使用220V的交流电，需要通过电源适配器将其转换为5V的直流电才能直接使用，这个电源适配器就是适配器模式中的适配器。 直接上代码： 构造方法一：传入参数为Callable接口 public FutureTas
Java并发课程之FutureTask
zdl_csdn的博客
11-22 259
Java并发课程之FutureTask 简介： 在Java中一般通过继承Thread类或者实现Runnable接口这两种方式来创建多线程，但是这两种方式都有个缺陷，就是不能在执行完成后获取执行的结果，因此Java 1.5之后提供了Callable和Future接口，通过它们就可以在任务执行完毕之后得到任务的执行结果。FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部
FutureTask分析
小萌新的博客
03-21 777
文章目录(一)关键概念点1、Future简介 (一)关键概念点 1、Future简介 Future是一个带泛型的接口类,主要定义了五个方法,大致分为三个作用：取消线程执行、线程是否取消或完成和获得返回值。 public interface Future<V> { //取消线程或中断线程 boolean cancel(boolean mayInterruptIfRunning); //是否被中断 boolean isCancelled(
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

徐同学呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值