【J.U.C-executors】执行器框架——Future模式

最新推荐文章于 2024-08-08 08:15:00 发布
最新推荐文章于 2024-08-08 08:15:00 发布
阅读量152 收藏
点赞数
分类专栏： Java并发 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sun_tantan/article/details/116611005
版权

目录

Future模式

  1. 在Java中如果要执行一个任务，一般要实现Runnable接口：
public class MyTask implements Runnable {
    @Override
    public void run() {
       
    }
}
  1. 但是如果需要得到任务执行的结果，则需要继承Callable接口：
public class MyTask implements Callable {
    @Override
    public Object call() {

    }
}
  • 背景：一般我们调用一个函数，只有等待函数执行结束后，才能继续往下执行；但是如果函数的执行时间较长，那么我们会使用异步任务的形式，创建一个新的线程进行调用。但是这种方式我们将不能得到其执行结果。

Future模式用于 异步 地获取任务的 执行结果 。

  • Future模式让调用方调用任务执行之后拿到一个 凭证（Future） ，然后立即返回；
  • 调用者可以先去执行其他的任务；
  • 在需要的时候，根据凭证去获取任务的执行结果。

Future接口、FutureTask类

Future即为我们获取到的凭证，它是一个接口：

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;
}
  • isCancelled：监控任务是否被取消
  • isDone：监控任是否执行结束
  • cancel：取消任务的执行
  • get：用于获取任务执行结果，如果调用时还没执行结束，将会阻塞（除非设置超时时间）

J.U.C为我们提供了Future接口的实现类：FutureTask。

使用Demo

创建任务，demo中是Runnable类型任务无返回值，也可以创建Callable带返回值的任务：

class MyRunnableTask implements Runnable {

    @Override
    public void run() {
        try {
            //任务执行耗时
            System.out.println("任务开始执行");
            Thread.sleep(3000);
            System.out.println("任务执行结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

有两种形式使用Future的方式：

  1. 直接使用Thread与FutureTask：
public class TestFuture {

    public static void main(String[] args) {
        MyRunnableTask myRunnableTask = new MyRunnableTask();
        FutureTask future = new FutureTask(myRunnableTask, null);
        Thread thread = new Thread(future);
        thread.start();
        System.out.println("main线程继续执行");
        try {
            future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("main线程执行结束");
    }
}
  1. 根据ExecutorService的submit方法：
public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        MyRunnableTask myRunnableTask = new MyRunnableTask();
        Future future = executorService.submit(myRunnableTask);
        executorService.shutdown();
        try {
            future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
}

看submit方法内部，其实也是创建了一个FutureTask进行返回：

	public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }

	protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }

Future接口实现类——FutureTask

1. 类继承关系

在这里插入图片描述
可知FutureTask是Future接口的实现类，另外还继承了Runnable接口，所以其本质是一个异步的任务。

  • 一方面是其Task的性质：我们可以将其提交给ThreadPoolExecutor执行，也可以直接调用run方法执行；
  • 另一方面是其Future的性质：我们可以对这个任务进行额外的操作，监控是否执行结束、获取执行结果等。

2. 存储结构与构造函数

 	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
    /** The thread running the callable; CASed during run() */
    private volatile Thread runner;
    /** Treiber stack of waiting threads */
    private volatile WaitNode waiters;

从JDK1.8开始，FutureTask使用volatile+CAS来实现同步，之前是实现了AQS框架。

  • state：任务状态值，volatile线程可见
  • callable：Callable类型的任务
  • outcome：调用get方法得到的返回值
  • runner：执行callable任务的Thread线程
  • waiters：一个链表结构，存储等待的线程
    WaitNode这个单向链表，在FutureTask中被当做线程安全的栈来使用，针对于多个线程同时入栈的情况（多个线程同时调用get方法）使用CAS保证入栈的线程安全，出栈也同理。
static final class WaitNode {
        volatile Thread thread;
        volatile WaitNode next;
        WaitNode() { thread = Thread.currentThread(); }
    }

此外还有一系列的UnSafe值记录：

// Unsafe mechanics
    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);
        }
    }

构造函数：

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
    }
  • 可见无论是Runnable类型还是Callable类型的任务都可以创建，它们最终都会被封装为Callable；
  • 任务的初始状态设为NEW

任务状态

  • NEW：表示任务的初始化状态；
  • COMPLETING：表示任务已执行完成（正常完成或异常完成），但任务结果或异常原因还未设置完成，属于中间状态；
  • NORMAL：表示任务已经执行完成（正常完成），且任务结果已设置完成，属于最终状态；
  • EXCEPTIONAL：表示任务已经执行完成（异常完成），且任务异常已设置完成，属于最终状态；
  • CANCELLED：表示任务还没开始执行就被取消（非中断方式），属于最终状态；
  • INTERRUPTING：表示任务还没开始执行就被取消（中断方式），正式被中断前的过渡状态，属于中间状态；
  • INTERRUPTED：表示任务还没开始执行就被取消（中断方式），且已被中断，属于最终状态。

可能的状态流转：

  1. NEW -> COMPLETING -> NORMAL
  2. NEW -> COMPLETING -> EXCEPTIONAL
  3. NEW -> CANCELLED
  4. NEW -> INTERRUPTING -> INTERRUPTED
  • 注意COMPLETING是已执行结束的状态，只是还未设置返回的结果。
  • 也就是说只要不是NEW状态，任务都已执行完了

3.结果获取

先看get方法：

public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }
  1. 如果任务的状态<COMPLETING，代表任务还未执行结束，调用awaitDone
  2. 调用report返回结果

3.1 awaitDone阻塞线程，返回任务状态

任务未执行完，将调用get的线程加入阻塞队列，挂起线程

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

首先区分两种线程的概念：

  • 一类是执行任务的线程（只有一个）执行FutureTask的run方法；
  • 一类是获取任务执行结果的线程（可以有多个，可并发执行）调用get方法来获取任务的执行结果。
    如果任务还没有执行完，则这些线程就需要进入线程安全的栈（也就是等待队列）中挂起，直到任务执行结束，或者等待的线程自身被中断。

再看其流程， 整体框架是一个自旋操作；

  1. 先检查当前线程是否被中断，如果被中断，removeWaiter将node从等待队列中移除
  2. 检查任务状态，如果这时已经进入终止状态，返回其状态；
  3. 如果处于COMPLETING执行完毕，还未设置结果完成的状态，Thread.yield()，让出当前线程的cpu继续等待；
  4. 否则任务正在执行中，创建一个节点q，并加入到链表的头结点之前，即入栈操作；
  5. 最后LockSupport.park将线程挂起。

自旋操作一直到线程被中断，或者是此线程再任务执行结束之后，finishCompletion方法中被唤醒。

3.2 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);
    }
  • 如果状态为正常，返回结果；
  • 状态为被取消、或有异常，返回相应的异常；

4.任务执行

public void run() {
        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 {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                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);
        }
    }
  • 通过CAS将runner设置为当前线程，记录执行任务的线程；
  • 调用call方法执行任务；
  • 执行任务成功，set(result)设置结果；执行失败，setException(ex)返回异常；
  1. 执行成功：set(result)
	protected void set(V v) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = v;
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
            finishCompletion();
        }
    }
  • 将stats由NEW改为COMPLETING
  • 给outcome赋值；
  • 将state修改为NORMAL最终态
  • finishCompletion完成执行结果的设置
  1. 执行失败：setException(ex)
	protected void setException(Throwable t) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = t;
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }
  • 将stats由NEW改为COMPLETING
  • 给outcome赋值为Throwable异常；
  • 将state修改为EXCEPTIONAL最终态
  • finishCompletion完成执行结果的设置

finishCompletion处理等待线程

private void finishCompletion() {
        // assert state > COMPLETING;
        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
    }
  • 将waiters的值设为null，目的就是清空整个栈；
  • 在for循环中遍历整个单向链表，LockSupport.unpark唤起等待线程；
sun_tantan
关注
专栏目录
吃透Java并发十九：线程池之Fork/Join框架（1） 原理
吃透Java
02-12 294
一、引言 算法领域有一种基本思想叫做“分治”，所谓“分治”就是将一个难以直接解决的大问题，分割成一些规模较小的子问题，以便各个击破，分而治之。 比如：对于一个规模为N的问题，若该问题可以容易地解决，则直接解决；否则将其分解为K个规模较小的子问题，这些子问题互相独立且与原问题性质相同，递归地解这些子问题，然后将各子问题的解合并得到原问题的解，这种算法设计策略叫做分治法。 许多基础算法都运用了“分治”...
手写中间件之——并行框架（3 异步回调如何实现）
tianyaleixiaowu的专栏
01-07 5328
上一篇主要讲了任务的编排该如何实现，包括串、并、串并结合。建议一定要手写个小demo去尝试各种基本组合。 这一篇主要是讲该如何实现异步回调。 如果之前有用过netty的应该知道，netty里大量充斥着“回调”，各种addListener，将各种耗时任务变成了异步带回调的模式。 回调是个很有用的模式，譬如我的主线程执行过程中，要执行一个非常耗时的逻辑，自然我们会想到用异步的形式去完成这个耗时逻...
【Java并发之执行器框架】 Executor
qq_35017434的博客
03-29 413
执行器框架分析
Executor（执行器）框架和Future框架
jingsuwen1的博客
07-29 3903
Future框架 Future接口定义了对线程执行计算结果的获取或取消线程执行该任务等操作。 两个重要的功能： 1.获取结果。 2.可取消性。 Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。取消则由 cancel 方法来执行。还提供了其他方法，以确
[笔记]Executors框架
iteye_20566的博客
03-08 85
框架结构 任务：Runnable和Callable 任务的执行：Executor接口-&gt;ExecutorService接口 ThreadPoolExecutor ScheduledThreadPoolExecutor 异步计算的结果：Future接口-&gt;FutureTask类 ThreadPoolExecutor new ThreadPoolExecutor(cor...
Java执行器框架（Executor Framework）提供了 ThreadPoolExecutor
人生如戏，程序当歌
04-12 674
Java执行器框架（Executor Framework）提供了 ThreadPoolExecutor ，通过线程池来执行并发任务从而避免了所以线程的创建操作。当发送一个任务给执行器后，根据执行器的配置，它将尽快地执行这个任务。当任务执行结束后，这个任务就会从执行器中删除；如果想再次执行这个任务，则需要再次发送这个任务到执行器。 上代码 package com.xingfu.wx; impo
Executor 、future学习（一）
somethingstill的博客
06-08 494
Android的线程池主要有4个 SingleThreadExecutor:单线程池，同时只有一个线程在跑 CachedThreadPool():回收线程池，可以重复利用之前创建过的线程，运行线程最大数是Integer.MAX_VALUE FixedThreadPool():固定大小的线程池，跟回收型线程池类似，只是可以限制同时运行的线程数量 ScheduledExecutorService:除了线程池的特性外，可以实现循环和延迟任务 使用new Thread()的缺陷 1.Java线程机制是抢
Java并发编程笔记——J.U.C之executors框架：executors框架设计理念
weixin_42300435的博客
02-25 303
一、executors框架简介 网上有太多文章讲executors框架，要么泛泛而谈，要么一叶障目不见泰山，缺乏整体视角，很多根本没有理解整个框架的设计思想和模块关系。本文将对整个executors框架做综述，介绍各个模块的功能和联系，后续再深入探讨每个模块，包括模块中的各个工具类。 从Executor谈起 Executor是JDK1.5时，随着J.U.C引入的一个接口，引入该接口的主...
Android框架——RxJava异步开发框架
是谁叫我
05-15 1172
介绍 RxJava是ReactiveX的Java实现，通过这个框架我们可以很方便的进行数据的异步获取，并对数据进行分步转换。 RxJava基本使用 引入依赖 implementation 'io.reactivex.rxjava2:rxandroid:2.1.0' implementation 'io.reactivex.rxjava2:rxjava:2.2.3' 创建观察者 首...
干货-并发编程提高——FutureTask（十）
最新发布
prince~home
08-08 1250
4. Callable任务被submit时，会生成一个FutureTask对象，封装Callable，在FutureTask的run方法里面执行Callable#call方法，并且调用java.util.concurrent.FutureTask#set设置Callable任务的执行结果(结果保存在一个FutureTask的Object类型的实例变量里面：private Object outcome;然后Executors是由java1.5引入的，框架最大的优点就是将执行任务与提交任务解耦出来。
监控执行器框架
西木空间
12-01 349
Java 9并发编程指南 目录 监控执行器框架准备工作实现过程工作原理更多关注 Executor框架将任务实现与线程创建和执行任务的管理分离开来。 如果使用执行器，只需要实现Runnable对象，然后发送到执行器即可。管理线程是执行器的责任，当向执行器发送任务时，它尝试使用池线程来执行任务，以避免创建新线程。这种机制由Executor接口及其实现类作为ThreadPoolExecutor类提供。 ...
Future,FutureTask,Executors,ExecutorService,Callable学习笔记
车前猛跑
09-03 933
1.Callable与Runnable类似，都可以作为线程任务被执行，但是Callable可以返回线程执行结果（通过Future.get()方法） 2.ExectuorService包含几个submit方法，主要用到2个，如下 submit(Callable task) submit(Runnable task) 3.ExecutorService可以通过Executors的几个工厂方
Java并发之执行器 ——Fork-Join框架
zl_momomo的博客
08-09 446
前言 Fork-Join将一个大任务分解成多个子任务，分别进行处理，最后再将处理结果合并。   双端队列与工作密取（Work Stealing） Fork-Join用到的模式 -工作密取 Java6 增加了两种容器类型，Deque (发 音 为 “deck”）和 BlockingDeque, 它们分别对 Queue和 BlockingQueue进行了扩展。Deque是一个双端队列，实现了...
Executor、future学习（二）
somethingstill的博客
06-10 562
Future future模式的核心思想是能够让主线程将原本需要同步等待的这段时间，用来做其他的事情，因为可以异步获得执行结果，所以不用一直同步等待去获取结果 future是个接口，future对具体的runnable或callable任务的执行结果进行取消，查询是否完成，获取结果，必要时可以通过get方法获取结果，该方法会阻塞直到任务返回结果 先看类图 主要方法： cancel：取消callable的执行 get：获得callable的返回值 isCanceled：判断是否取消 isD
java线程执行器框架介绍（一）--ThreadPoolExecutor
panda-star的博客
06-09 453
在java多线程开发中，当我们需要批量执行多个任务线程时，可以使用java的执行器框架。 也就是Executors工厂类生成的各种Executor实现类。我们在这里介绍ThreadPoolExecutor。 1、由Executors工厂类生成的ThreadPoolExecutor包含如下几类: a)newCachedThreadPool，不指定线程个数，通常用于执行线程不多的情况； b
【详解】Executors框架之Future&Callable
xzzz2020的博客
05-11 304
简介 这个思想来源于Future设计模式：https://blog.csdn.net/qq_43040688/article/details/105868293 public interface Callable<V> { V call() throws Exception; } 可以看到，这是一个泛型接口，该接口声明了一个名称为call()的方法，同时这个方法可以有返回值V，也可以抛出异常。call()方法返回的类型就是传递进来的V类型。 那么怎么使用Callable呢？一般情况
6.执行器框架的应用ThreadPoolExecutor、Executors
拔起最后一根救命稻草
05-05 185
执行器框架的应用执行器框架的应用ThreadPoolExecutorExecutors 创建线程池线程池的状态 执行器框架的应用 ThreadPoolExecutor Executors 创建线程池 线程池的状态 本文如有任何问题，请留言指教，以免误导他人 ...
java线程执行器框架介绍（二）--ScheduledThreadPoolExecutor
panda-star的博客
06-09 423
在java多线程操作中，我们有时需要延时或才周期性的执行某些执行，这时我们可以使用ScheduledThreadPoolExecutor。 一、工厂类Executors生成的ScheduledThreadPoolExecutor 1、newSingleThreadScheduledExecutor，单个线程 2、newSingleThreadScheduledExecutor，指定线程 二
Executor、future学习（三）
somethingstill的博客
06-10 180
线程池主要有4个 SingleThreadExecutor:单线程池，同时只有一个线程在跑 CachedThreadPool():回收线程池，可以重复利用之前创建过的线程，运行线程最大数是Integer.MAX_VALUE FixedThreadPool():固定大小的线程池，跟回收型线程池类似，只是可以限制同时运行的线程数量 ScheduledExecutorService:除了线程池的特性外，可以实现循环和延迟任务 使用new Thread()的缺陷 1.Java线程机制是抢占性的，new
threadPool.execute(() -> { // 执行任务 });这段代码完善一下
05-05
ExecutorService threadPool = Executors.newFixedThreadPool(10); // 提交任务到线程池 threadPool.execute(() -> { // 执行任务 // TODO: 在这里添加具体的任务逻辑 }); // 关闭线程池 threadPool.shutdown();...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值