多线程与高并发——并发编程(8)

文章目录

  • 八、异步编程
    • 1 FutureTask应用&源码分析
      • 1.1 FutureTask介绍
      • 1.2 FutureTask应用
      • 1.3 FutureTask源码分析
        • 1.3.1 FutureTask中的核心属性
        • 1.3.2 FutureTask的run方法
        • 1.3.3 FutureTask的set&setException方法
        • 1.3.4 FutureTask的cancel方法
        • 1.3.5 FutureTask的get方法
        • 1.3.6 FutureTask的finishCompletion方法
    • 2 CompletableFuture应用&源码分析
      • 2.1 CompletableFuture介绍
      • 2.2 CompletableFuture应用
        • 2.2.1 supplyAsync方法
        • 2.2.2 runAsync方法
        • 2.2.3 thenApply、thenApplyAsync
        • 2.2.4 thenAccept、thenAcceptAsync
        • 2.2.5 thenRun、thenRunAsync
        • 2.2.6 thenCombine、thenAcceptBoth、runAfterBoth
        • 2.2.7 applyToEither、acceptEither、runAfterEither
        • 2.2.8 exceptionally、thenCompose、handle
        • 2.2.9 allOf、anyOf
      • 2.3 CompletableFuture源码分析
        • 2.3.1 当前任务执行方式
        • 2.3.2 任务编排的存储&执行方式
        • 2.3.3 任务编排流程
        • 2.3.4 查看后置任务执行时机
      • 2.4 CompletableFuture执行流程

八、异步编程

1 FutureTask应用&源码分析

1.1 FutureTask介绍

  • FutureTask 是一个可以取消一部任务的类,FutureTask 对 Future 做了一个基本实现,可以调用方法去开始和取消一个任务,一般是配合 Callable 使用。
  • 异步任务启动之后,可以获取一个绑定当前异步任务的 FutureTask。
  • 可以基于 FutureTask 的方法去取消任务、查看任务是否有结果,以及获取任务的返回结果。
  • FutureTask内部的整体结构中,实现了 RunnableFuture 接口,RunnableFuture 这个接口又继承了 Runnable、Future 这两个接口,所以 FutureTask 也可以作为任务直接交给线程池去处理。

1.2 FutureTask应用

大方向是 FutureTask 对任务的控制:

  • 任务执行过程中状态的控制;
  • 任务执行完毕后,返回结果的获取。

FutureTask 的任务在执行 run 方法后,是无法被再次运行的,需要使用 runAndReset 方法才可以。

public static void main(String[] args) throws InterruptedException {
    // 构建FutureTask,基于泛型执行返回结果类型
    // 在有参构造中,声明Callable或者Runnable指定任务
    FutureTask futureTask = new FutureTask<>(() -> {
        System.out.println("任务开始执行……");
        Thread.sleep(2000);
        System.out.println("任务执行完毕……");
        return "OK!";
    });

    // 构建线程池
    ExecutorService service = Executors.newFixedThreadPool(10);

    // 线程池执行任务
    service.execute(futureTask);

    // 1. 对任务状态的控制
//        System.out.println("任务结束了么?:" + futureTask.isDone());
//        Thread.sleep(1000);
//        System.out.println("任务结束了么?:" + futureTask.isDone());
//        Thread.sleep(1000);
//        System.out.println("任务结束了么?:" + futureTask.isDone());

    // 2. 对返回结果的获取,类似阻塞队列的take方法,死等结果
//        try {
//            String s = futureTask.get();
//            System.out.println("任务结果:" + s);
//        } catch (ExecutionException e) {
//            e.printStackTrace();
//        }
    // 3. 对返回结果的获取,类似阻塞队列的poll方法
    // 如果在指定时间内,没有拿到方法的返回结果,直接扔TimeoutException
//        try {
//            String s = futureTask.get(3000, TimeUnit.MILLISECONDS);
//            System.out.println("返回结果:" + s);
//        } catch (Exception e) {
//            System.out.println("异常返回:" + e.getMessage());
//            e.printStackTrace();
//        }

    // 4. futureTask提供了run方法,一般不会自己去调用run方法,而是让线程池去执行任务,由线程池去执行run方法
    // run方法在执行时,是有任务状态的。任务已经执行了,再次调用run方法无效的。
    // 如果希望任务可以反复被执行,需要去调用runAndReset方法
//        futureTask.run();
}

1.3 FutureTask源码分析

  • 查看FutureTask 的源码,要从几个方向去看:
    • 先查看 FutureTask 中提供的一些状态;
    • 再查看任务的执行过程

1.3.1 FutureTask中的核心属性

  • 首先弄清楚任务的状态流转是怎样的,其次对于核心属性要知道是干嘛的。
/**
 FutureTask的核心属性
 FutureTask任务的状态流转
 * NEW -> COMPLETING -> NORMAL           任务正常执行,并且返回结果也正常返回
 * NEW -> COMPLETING -> EXCEPTIONAL      任务正常执行,但是结果是异常
 * NEW -> CANCELLED                      任务被取消   
 * NEW -> INTERRUPTING -> INTERRUPTED    任务被中断
 */
// 记录任务的状态
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;

// 需要执行任务,会被赋值到这个属性
private Callable callable;
// 任务的任务结果要存储在这几个属性中
private Object outcome; // non-volatile, protected by state reads/writes
// 执行任务的线程
private volatile Thread runner;
// 等待返回结果的线程Node对象
private volatile WaitNode waiters;
static final class WaitNode {
    volatile Thread thread;
    volatile WaitNode next;
    WaitNode() { thread = Thread.currentThread(); }
}

1.3.2 FutureTask的run方法

  • 任务执行前的一些判读,以及调用任务封装结果的方式,还有最后的一些后续处理。
// 当线程池执行FutureTask任务时,会调用的方法
public void run() {
   
    // 如果当前任务状态不是NEW,直接return告辞
    if (state != NEW ||  
        // 如果状态正确是NEW,这边需要基于CAS将runner属性设置为当前线程,如果CAS失败,直接return告辞
        !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
        return;
    try {
   
        // 将要执行的任务拿到
        Callable<V> c = callable;
        // 健壮性判断,保证任务不是null,再次判断任务的状态是NEW(DCL)
        if (c != null && state == NEW) {
   
            // 执行任务
            // result:任务的返回结果
            // ran:如果为true,任务正常结束。 如果为false,任务异常结束。
            V result;
            boolean ran;
            try {
   
                result = c.call();	// 执行任务
                ran = true;			// 正常结果,ran设置为true
            } catch (Throwable ex) {
   
                // 如果任务执行期间出了异常,返回结果置为null
                result = null;
                ran = false;		// ran设置为false
                setException(ex);	// 封装异常结果
            }
            if (ran)
                set(result);		// 封装正常结果
        }
    } finally {
   
        runner = null;		// 将执行任务的线程置为null
        int s = state;		// 拿到任务的状态
        if (s >= INTERRUPTING)	// 如果状态大于等于INTERRUPTING
            // 进来代表任务中断,做一些后续处理
            handlePossibleCancellationInterrupt(s);
    }
}

1.3.3 FutureTask的set&setException方法

  • 任务执行完毕后,修改任务的状态以及封装任务的结果
// 没有异常的时候,正常返回结果
protected void set(V v) {
   
    // 因为任务执行完毕,需要将任务的状态从NEW,修改为COMPLETING
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
   
        // 将返回结果赋值给 outcome 属性
        outcome = v;
        // 将任务状态变为NORMAL,正常结束
        UNSAFE.putOrderedInt(this, stateOffset, NORMAL);
        // 一会再说……
        finishCompletion();
    }
}
// 任务执行期间出现了异常,这边要封装结果
protected void setException(Throwable t) {
   
    // 因为任务执行完毕,需要将任务的状态从NEW,修改为COMPLETING
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
   
        // 将异常信息封装到 outcome 属性
        outcome = t;
        // 将任务状态变为EXCEPTIONAL,异常结束
        UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); 
        // 一会再说……
        finishCompletion();
    }
}

1.3.4 FutureTask的cancel方法

  • 任务取消的一个方式:
    • 任务直接从 NEW 状态转换为 CANCEL
    • 任务从 NEW 状态变为 INTERRUPTING,然后再转换为 INTERRUPTED
// 取消任务操作
public boolean cancel(boolean mayInterruptIfRunning) {
   
    // 查看任务的状态是否是NEW,如果NEW状态,就基于传入的参数mayInterruptIfRunning
    // 决定任务是直接从NEW转换为CANCEL,还是从NEW转换为INTERRUPTING
    if (!(state == NEW && 
        UNSAFE.compareAndSwapInt(this, stateOffset, NEW, mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
        return false;
    try {
      
        // 如果mayInterruptIfRunning为true,就需要中断线程
        if (mayInterruptIfRunning) {
   
            try {
   
                Thread t = runner;	// 拿到任务线程
                if (t != null)		// 如果线程不为null,直接interrupt   
                    t.interrupt();
            } finally {
    
                // 将任务状态设置为INTERRUPTED
                UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
            }
        }
    } finally {
   
        // 任务结束后的一些处理~~ 一会看~~
        finishCompletion();
    }
    return true;
}

1.3.5 FutureTask的get方法

  • 这个是线程获取 FutureTask 任务执行结果的方法
// 拿任务结果
public V get() throws InterruptedException, ExecutionException {
   
    // 获取任务的状态
    int s = state;
    // 要么是NEW,任务还没执行完;要么COMPLETING,任务执行完了,结果还没封装好
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);	// 让当前线程阻塞,等待结果
    return report(s);				// 最终想要获取结果,需要执行report方法
}
// 线程等待FutureTask结果的过程
private int awaitDone(boolean timed, long nanos) throws InterruptedException {
   
    // 针对get方法传入了等待时长时,需要计算等到什么时间点
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    // 声明好需要的Node,queued:放到链表中了么
    WaitNode q = null;
    boolean queued = false;
    for (;;) {
   
        // 查看线程是否中断,如果中断,从等待链表中移除,甩个异常
        if (Thread.interrupted()) {
   
            removeWaiter(q);
            throw new InterruptedException();
        }
        int s = state;			// 拿到状态
        if (s > COMPLETING) 

你可能感兴趣的:(Java多线程并发编程,并发编程,异步编程,Future)