小波同学
小波同学

Java并发编程——CompletableFuture源码解析

前言

JDK8 为我们带来了 CompletableFuture 这个有意思的新类，它提供比 Future 更灵活更强大的回调功能，借助 CompletableFuture 我们可以更方便的编排异步任务。

由于 CompletableFuture 默认的线程池是 ForkJoinPool，在讲 CompletableFuture 之前觉得有必要先简单介绍一下 ForkJoinPool。

一、ForkJoinPool 工作原理

ForkJoin 框架，另一种风格的线程池（相比于 ThreadPoolExecutor），采用分治算法，以及工作窃取策略，极大地提高了并行性。对于那种大任务分割小任务的（分治）又或者并行计算场景尤其有用。

1.1 ForkJoinPool

线程池，ForkJoinPool 类中有一个commonPool，默认并发数为逻辑处理器个数 - 1；

ForkJoinPool commonPool = ForkJoinPool.commonPool();//makeCommonPool

//看源码发现 
int parallelism = System.getProperty("java.util.concurrent.ForkJoinPool.common.parallelism");
// 如果有自定义，那么取自定义的作为 parallelism
// 如果没有 逻辑处理器个数-1 
parallelism = Runtime.getRuntime().availableProcessors() - 1

当然了，如果你不想使用 commonPool，你完全可以直接new 一个

ForkJoinPool fjp = new ForkJoinPool(4);// 最大并发数4

其实我当时有个疑问，明明可以直接 new 一个 ForkJoinPool，还可以很方便的指定parallelism（我写的ForkJoinTest就是通过这种方式），为什么 ForkJoinPool 中还定义一个static的commonPool？

commonPool一般用于 Java8 中的并发流计算中或者 CompletableFuture 没有指定线程池时使用的一个commonPool。

1.2 ForkJoinTask

ForkJoinPool 与 ForkJoinTask 之间的关系，可以类比 ThreadPoolExecutor 和 Runnable 的关系，都可以理解为提交任务到线程池，只不过分治任务有自己独特类型 ForkJoinTask。它是一个抽象类。主要有两个实现RecursiveAction（有返回值） 和 RecursiveTask（无返回值）

1.3 ForkJoinWorkerThread

运行 ForkJoinTask 任务的工作线程（worker），最大并发数不会超过parallelism。

1.4 WorkQueue

任务队列，每个worker对应一个queue,这是和 ThreadPoolExecutor 最大不同的地方之一。

1.5 WorkQueue[]

ForkJoinPool 中的任务分为两种，一种是本地提交的任务Submission task，通过execute()、submit()、invoke()等方法提交的任务；比如 CompletableFuture 中不提供线程池时，提交的都是Submission task。

另外一种是工作线程fork出的子任务Worker task。

两种任务都会存放在WorkQueue数组中，Submission task存放在WorkQueue数组的偶数索引位置，Worker task存放在奇数索引位置。工作线程只会分配在奇数索引的工作队列。

1.6 工作窃取机制

工作窃取是指当某个线程的任务队列中没有可执行任务的时候，从其他线程的任务队列中窃取任务来执行，以充分利用工作线程的计算能力，减少线程由于获取不到任务而造成的空闲浪费。在 ForkJoinPool 中，工作任务的队列都采用双端队列容器。我们知道，在通常使用队列的过程中，我们都在队尾插入，而在队头消费以实现 FIFO。而为了实现工作窃取。一般我们会改成工作线程在工作队列上 LIFO，而窃取其他线程的任务的时候，从队列头部取获取。

工作线程worker1、worker2以及worker3都从WorkQueue的尾部popping获取task，而任务也从尾部Pushing，当worker3队列中没有任务的时候，就会从其他线程的队列中窃取stealing，这样就使得 worker3 不会由于没有任务而空闲。这就是工作窃取算法的基本原理。 可以想象，要是不使用工作窃取算法，那么我们在不断 fork 的过程中，可能某些 worker 就会一直处于 join 的等待中。

因为这种机制，它能够让所有线程的工作量基本均衡，不会出现有的线程很忙，而有的线程很闲的状况，所以性能很好。

  • 1、为什么说 ForkJoinPool 并发访问一个 IO 计算可能会拖垮整个系统？
    这主要说的是 ForkJoinPool 中的 commonPool，commonPool 是整个·系统共享的。比如你在 Stream 并行流中并发访问一个 IO 计算，某一时刻会导致commonPool 中大部分线程甚至所有线程都阻碍在这里。这可能就会造成其他程序使用到 commonPool 的程序线程饥饿，比如 CompletableFuture 中没有指定线程池时。

  • 2、为什么说 cpu 密集型的任务使用 ForkJoinPool 性能更好？
    网上说主要有工作窃取机制。工作窃取的目的不就是充分利用 cpu，那普通线程不也可以吗，把核心线程调成和 ForkJoinPool 默认线程。

CompletableFuture 使用总结

关于 CompletableFuture（异步计算）的使用，比如订单列表的并发请求远程服务，服务中异步处理一些任务，又或者异步导出，并发处理数据等等。

按功能分类

  • xxx()：表示该方法将继续在已有的线程中执行；
  • xxxAsync()：表示将异步在线程池中执行。
  • 异步执行方法默认一个参数的话任务是在 ForkJoinPool.commonPool() 线程池中执行的（带看源码），带executor 参数的使用 executor线程池异步执行。

按逻辑和组织方式来分的话(completableFuture 中大约有50个来方法)

  • 一种是 then 的逻辑，即前一个计算完成的时候调度后一个计算
  • 一种是 both 的逻辑，即等待两个计算都完成之后执行下一个计算，只要能组合一个和另一个，我们就可以无限复用这个 +1 的逻辑组合任意多的计算。(如果任务多，可以考虑可用allOf)
  • 另一种是 either 的逻辑，即等待两个计算的其中一个完成之后执行下一个计算。注意这样的计算可以说是非确定性的。因为被组合的两个计算中先触发下一个计算执行的那个会被作为前一个计算，而这两个前置的计算到底哪一个先完成是不可预知的（anyOf）

从依赖关系和出入参数类型区别，基本分为三类

  • apply 字样的方式意味着组合方式是 Function，即接受前一个计算的结果，应用函数之后返回一个新的结果。
  • accept 字样的方式意味着组合方式是 Consumer，即接受前一个计算的结果，执行消费后不返回有意义的值。
  • run 字样的方式意味着组合方式是 Runnable，即忽略前一个计算的结果，仅等待它完成后执行动作。

其中出入参数主要有 Java8 Function，Consumer 或 Runnable三中函数型接口，每一种都决定了是怎么样一种依赖关系

二、数据结构

2.1、CompletableFuture

CompletableFuture 实现了 Future 接口和 CompletionStage，Future 不必多说，而 CompletionStage 定义了各种任务编排的 API：

CompletableFuture implements Future, CompletionStage {
    volatile Object result;       // Either the result or boxed AltResult
    volatile Completion stack;    // Top of Treiber stack of dependent actions
}

CompletableFuture 的数据结构包括用于记录结果的 result，以及用于持有任务以及任务间依赖关系的 Completion 类型的成员变量 stack。

如果阅读过 spring 注解相关功能的源码的同学，对于 CompletableFuture 和 Completion 应该会有一种 TypeMappedAnnotation 和 AnnotationTypeMapping 的既视感，实际上他们两者之间的关系确实也非常相似。

2.2、Completion

数据结构

Completion 是 CompletableFuture 中的一个内部类，我们可以简单的认为它就是我们一般所说的“操作”。

abstract static class Completion extends ForkJoinTask
    implements Runnable, AsynchronousCompletionTask {
    volatile Completion next;
}

它通过 next 指针在 CompletableFuture 中形成一个链表结构。

依赖关系

它还有两个抽象的实现类 UniCompletion 和 BiCompletion：

abstract static class UniCompletion extends Completion {
        Executor executor;                 // executor to use (null if none)
        CompletableFuture dep;          // the dependent to complete
        CompletableFuture src;          // source for action
}

abstract static class BiCompletion extends UniCompletion {
        CompletableFuture snd; // second source for action
}

其中 executor 表示该操作的执行者，而 src 和 snd 两个指针表示要执行的操作对应的 CompletableFuture 实例，而 dep 则表示要执行的操作依赖的前置操作对应的 CompletableFuture 实例。多个 Completion 彼此之间通过这些指针维护彼此的依赖关系。

实现类

在 CompletableFuture，我们会看到很多格式为 UniXXX 或者 BiXXX 的内部类，它们大多数都基于上述两抽象类实现，分别对应不同的操作。我们以 UniApply 为例：

static final class UniApply extends UniCompletion {
    Function fn;
}

其本质上就是一个额外挂载了 Function 接口的 UniCompletion，同理，XXXAccept 就是挂载了 Consumer 的 Completion，而 XXXRun 就是挂载的 Runnable 接口的 Completion。

三、源码分析

样例

后面介绍的源码都会以下面的用例为切入点，循着调用轨迹理解源码。如果任务很耗时，记得传Executor, 或者方法末尾加上future.get(); 因为CompletableFuture默认使用ForkJoinPool, 而ForkJoinPool里面的线程都是daemon线程，主线程跑完了，虚拟机也就over了。

public void whenComplete() {
    CompletableFuture future = CompletableFuture.supplyAsync(() -> 100);
    future.whenComplete((l, r) -> System.out.println(l));
}

public void thenApply() {
    CompletableFuture future = CompletableFuture.supplyAsync(() -> 100);
    future.thenApply(i -> -i);
}

public void thenAccept() {
    CompletableFuture future = CompletableFuture.supplyAsync(() -> 100);
    future.thenAccept(System.out::println);
}

public void thenRun() {
    CompletableFuture future = CompletableFuture.supplyAsync(() -> 100);
    future.thenRun(() -> System.out.println("Done"));
}

public void thenAcceptBoth() {
    CompletableFuture future = CompletableFuture.supplyAsync(() -> 100);
    CompletableFuture other = CompletableFuture.supplyAsync(() -> 200);
    future.thenAcceptBoth(other, (x, y) -> System.out.println(x + y));
}

public void acceptEither() {
    CompletableFuture future = CompletableFuture.supplyAsync(() -> 100);
    CompletableFuture other = CompletableFuture.supplyAsync(() -> 200);
    future.acceptEither(other, System.out::println);
}

public void allOf() {
    CompletableFuture future = CompletableFuture.supplyAsync(() -> 100);
    CompletableFuture second = CompletableFuture.supplyAsync(() -> 200);
    CompletableFuture third = CompletableFuture.supplyAsync(() -> 300);
    CompletableFuture.allOf(future, second, third);
}

public void anyOf() throws InterruptedException, ExecutionException {
    CompletableFuture future = CompletableFuture.supplyAsync(() -> 100);
    CompletableFuture second = CompletableFuture.supplyAsync(() -> 200);
    CompletableFuture third = CompletableFuture.supplyAsync(() -> 300);
    CompletableFuture.anyOf(future, second, third);
}

3.1 supplyAsync(Supplier supplier)

public static  CompletableFuture supplyAsync(Supplier supplier) {
    // asyncPool, ForkJoinPool.commonPool()或者ThreadPerTaskExecutor(实现了Executor接口，里面的内容是{new Thread(r).start();})
    return asyncSupplyStage(asyncPool, supplier); 
}

3.2 asyncSupplyStage(Executor e, Supplier f)

static  CompletableFuture asyncSupplyStage(Executor e, Supplier f) {
    if (f == null)
        throw new NullPointerException();
    // 构建一个新的CompletableFuture, 以此构建AsyncSupply作为Executor的执行参数
    CompletableFuture d = new CompletableFuture(); 
    // AsyncSupply继承了ForkJoinTask, 实现了Runnable, AsynchronousCompletionTask接口
    e.execute(new AsyncSupply(d, f)); 
    // 返回d，立返
    return d; 
}

3.3 AsyncSupply

// CompletableFuture的静态内部类，作为一个ForkJoinTask
static final class AsyncSupply extends ForkJoinTask implements Runnable, AsynchronousCompletionTask {
    // AsyncSupply作为一个依赖Task，dep作为这个Task的Future
    CompletableFuture dep; 
    
    // fn作为这个Task的具体执行逻辑，函数式编程
    Supplier fn; 

    AsyncSupply(CompletableFuture dep, Supplier fn) {
        this.dep = dep;
        this.fn = fn;
    }

    public final Void getRawResult() {
        return null;
    }

    public final void setRawResult(Void v) {
    }

    public final boolean exec() {
        run();
        return true;
    }

    public void run() {
        CompletableFuture d;
        Supplier f;
        if ((d = dep) != null && (f = fn) != null) { // 非空判断
            dep = null;
            fn = null;
            // 查看任务是否结束，如果已经结束(result != null)，直接调用postComplete()方法
            if (d.result == null) { 
                try {
                    // 等待任务结束，并设置结果
                    d.completeValue(f.get()); 
                } catch (Throwable ex) {
                    d.completeThrowable(ex); // 异常
                }
            }
            // 任务结束后，会执行所有依赖此任务的其他任务，这些任务以一个无锁并发栈的形式存在
            d.postComplete(); 
        }
    }
}

3.4 postComplete()

final void postComplete() {
    // 当前CompletableFuture
    CompletableFuture f = this; 
    // 无锁并发栈，(Completion next), 保存的是依靠当前的CompletableFuture一串任务，完成即触发（回调）
    Completion h; 
    
    // 当f的stack为空时，使f重新指向当前的CompletableFuture，继续后面的结点
    while ((h = f.stack) != null || (f != this && (h = (f = this).stack) != null)) { 
        CompletableFuture d;
        Completion t;
        
        // 从头遍历stack，并更新头元素
        if (f.casStack(h, t = h.next)) { 
            if (t != null) {
                // 如果f不是当前CompletableFuture，则将它的头结点压入到当前CompletableFuture的stack中，使树形结构变成链表结构，避免递归层次过深
                if (f != this) { 
                    pushStack(h);
                    // 继续下一个结点，批量压入到当前栈中
                    continue; 
                }
                // 如果是当前CompletableFuture, 解除头节点与栈的联系
                h.next = null; 
            }
            // 调用头节点的tryFire()方法，该方法可看作Completion的钩子方法，执行完逻辑后，会向后传播的
            f = (d = h.tryFire(NESTED)) == null ? this : d; 
        }
    }
}

示意图

每个CompletableFuture持有一个Completion栈stack, 每个Completion持有一个CompletableFuture -> dep, 如此递归循环下去，是层次很深的树形结构，所以想办法将其变成链表结构。


首先取出头结点，下图中灰色Completion结点，它会返回一个CompletableFuture, 同样也拥有一个stack，策略是遍历这个CompletableFuture的stack的每个结点，依次压入到当前CompletableFuture的stack中，关系如下箭头所示，灰色结点指的是处理过的结点。


第一个Completion结点返回的CompletableFuture, 将拥有的stack里面的所有结点都压入了当前CompletableFuture的stack里面。


后续的Completion结点返回的CompletableFuture, 将拥有的stack里面的所有结点都压入了当前CompletableFuture的stack里面，重新构成了一个链表结构，后续也按照前面的逻辑操作，如此反复，便会遍历完所有的CompletableFuture, 这些CompletableFuture(叶子结点)的stack为空，也是结束条件。


postComplete()最后调用的是Completion#tryFire()方法，先看下Completion的数据结构

Completion

abstract static class Completion extends ForkJoinTask implements Runnable, AsynchronousCompletionTask {
    volatile Completion next; // 无锁并发栈

    /**
     * 钩子方法，有三种模式，postComplete()方法里面使用的是NESTED模式，避免过深的递归调用 SYNC, ASYNC, or NESTED
     */
    abstract CompletableFuture tryFire(int mode); // run()和exec()都调用了这个钩子方法

    /** cleanStack()方法里有用到 */
    abstract boolean isLive();

    public final void run() {
        tryFire(ASYNC);
    }

    public final boolean exec() {
        tryFire(ASYNC);
        return true;
    }

    public final Void getRawResult() {
        return null;
    }

    public final void setRawResult(Void v) {
    }
}

static final int SYNC = 0; 同步
static final int ASYNC = 1; 异步
static final int NESTED = -1; 嵌套

继承了ForkJoinTask, 实现了Runnable, AsynchronousCompletionTask接口，它有诸多子类，如下图


后面的方法都对应着不同的子类。

先看一个子类UniCompletion

abstract static class UniCompletion extends Completion {
    Executor executor;                 // 执行器
    CompletableFuture dep;          // 依赖的任务
    CompletableFuture src;          // 被依赖的任务

    UniCompletion(Executor executor, CompletableFuture dep,
                    CompletableFuture src) {
        this.executor = executor; this.dep = dep; this.src = src;
    }

    // 如果当前任务可以被执行，返回true，否则，返回false; 保证任务只被执行一次
    final boolean claim() { 
        Executor e = executor;
        if (compareAndSetForkJoinTaskTag((short)0, (short)1)) {
            if (e == null)
                return true;
            executor = null; // 设置为不可用
            e.execute(this);
        }
        return false;
    }

    final boolean isLive() {
        return dep != null; 
    }
}

claim()方法保证任务只被执行一次。

whenComplete

whenComplete()/whenCompleteAsync()

public CompletableFuture whenComplete(BiConsumer action) {
    return uniWhenCompleteStage(null, action);
}

public CompletableFuture whenCompleteAsync(BiConsumer action) {
    return uniWhenCompleteStage(asyncPool, action);
}

xxx和xxxAsync方法的区别是，有没有asyncPool作为入参，有的话，任务直接入参，不检查任务是否完成。uniWhenCompleteStage方法有说明。

uniWhenCompleteStage(Executor e, BiConsumer f)

private CompletableFuture uniWhenCompleteStage(Executor e, BiConsumer f) {
    if (f == null)
        throw new NullPointerException();
        // 构建future
        CompletableFuture d = new CompletableFuture(); 
    if (e != null || !d.uniWhenComplete(this, f, null)) { // 如果线程池不为空，直接构建任务入栈，并调用tryFire()方法；否则，调用uniWhenComplete()方法，检查依赖的那个任务是否完成，没有完成返回false,
                                                         // 完成了返回true, 以及后续一些操作。
         UniWhenComplete c = new UniWhenComplete(e, d, this, f); // UniWhenComplete继承了UniCompletion
         push(c);
         c.tryFire(SYNC); // 先调一下钩子方法，检查一下任务是否结束
    }
    return d;
}

uniWhenComplete(CompletableFuture a, BiConsumer f, UniWhenComplete c)

final boolean uniWhenComplete(CompletableFuture a, BiConsumer f, UniWhenComplete c) {
    Object r;
    T t;
    Throwable x = null;
    if (a == null || (r = a.result) == null || f == null) // 被依赖的任务还未完成
        return false;
    if (result == null) { // 被依赖的任务完成了
        try {
            if (c != null && !c.claim()) // 判断任务是否能被执行
                return false;
            if (r instanceof AltResult) { // 判断异常，AltResult类型很简单，里面只有一个属性Throwable ex; 
                x = ((AltResult) r).ex;
                t = null;
            } else {
                @SuppressWarnings("unchecked")
                T tr = (T) r; // 正常的结果
                t = tr;
            }
            f.accept(t, x); // 执行任务
            if (x == null) {
                internalComplete(r); // 任务的结果设置为被依赖任务的结果
                return true;
            }
        } catch (Throwable ex) {
        if (x == null)
            x = ex; // 记录异常
        }
        completeThrowable(x, r); // 设置异常和结果
    }
    return true;
}

push()

final void push(UniCompletion c) {
    if (c != null) {
        while (result == null && !tryPushStack(c))
            lazySetNext(c, null); // 失败重置c的next域
    }
}

final boolean tryPushStack(Completion c) {
    Completion h = stack;
    lazySetNext(c, h);
    return UNSAFE.compareAndSwapObject(this, STACK, h, c);
}

static void lazySetNext(Completion c, Completion next) {
    UNSAFE.putOrderedObject(c, NEXT, next);
}

UniWhenComplete

static final class UniWhenComplete extends UniCompletion {
    BiConsumer fn;

    UniWhenComplete(Executor executor, CompletableFuture dep, CompletableFuture src,
         BiConsumer fn) {
        super(executor, dep, src);
        this.fn = fn;
    }

    final CompletableFuture tryFire(int mode) { // 钩子方法
        CompletableFuture d; // 依赖的任务
        CompletableFuture a; // 被依赖的任务
        if ((d = dep) == null || !d.uniWhenComplete(a = src, fn, mode > 0 ? null : this)) // 如果是异步模式(mode = 1),就不判断任务是否结束
            return null; // dep为空，说明已经调用过了
        dep = null;
        src = null;
        fn = null;
        return d.postFire(a, mode); // 钩子方法之后的处理
    }
}

postFire(CompletableFuture a, int mode)

final CompletableFuture postFire(CompletableFuture a, int mode) {
    if (a != null && a.stack != null) { // 被依赖的任务存在，且stack不为空，先处理它
        if (mode < 0 || a.result == null) // 如果是嵌套模式(mode = -1), 或者任务的结果为空，直接清空栈
            a.cleanStack();
        else
            a.postComplete(); // 否则，调用postComplete()方法
    }
    if (result != null && stack != null) { // 再处理当前任务
        if (mode < 0) // 嵌套模式，直接返回自身(树 -> 链表，避免过深的递归调用)
            return this;
        else
            postComplete(); // 调用postComplete()方法
    }
    return null;
}

cleanStack()

final void cleanStack() { // 过滤掉已经死掉的结点(Not isLive)
    for (Completion p = null, q = stack; q != null;) { // q指针从头节点开始，向右移动，s一直执行q的下一个结点，p要么为空，要么指向遍历过的最后一个活着的结点，一旦发现q死掉了，就断开q, 连接p, s
        Completion s = q.next;
        if (q.isLive()) { // 还活着，p指向遍历过的最后一个结点，q向右移动
            p = q;
            q = s;
        } else if (p == null) { // 说明第一个结点就是死掉的，cas stack, q指向stack
            casStack(q, s);
            q = stack;
        } else { // 否则的话，连接p, s
        p.next = s;
            if (p.isLive()) // 再次判断p结点是否还或者(在这期间是否有别的线程改动了)
                q = s; // 还活着，q继续向右移动
            else {
                p = null; // 过期的值，从新开始
                q = stack;
            }
        }
    }
}

如下图

    1. 第1个结点是无效结点，更新stack，更新指针


    1. 第2个结点是有效结点，更新指针


    1. 第3个结点是无效结点，更新指针


    1. 第4个结点是有效结点，更新指针


thenApply

public  CompletableFuture thenApply(Function fn) {
    return uniApplyStage(null, fn);
}

public  CompletableFuture thenApplyAsync(Function fn) {
    return uniApplyStage(asyncPool, fn);
}

private  CompletableFuture uniApplyStage(Executor e, Function f) {
    if (f == null)
        throw new NullPointerException();
    CompletableFuture d = new CompletableFuture();
    if (e != null || !d.uniApply(this, f, null)) {
        UniApply c = new UniApply(e, d, this, f);
        push(c);
        c.tryFire(SYNC);
    }
    return d;
}

final  boolean uniApply(CompletableFuture a, Function f, UniApply c) {
    Object r;
    Throwable x;
    if (a == null || (r = a.result) == null || f == null)
        return false;
    tryComplete: if (result == null) {
        if (r instanceof AltResult) {
            if ((x = ((AltResult) r).ex) != null) {
                completeThrowable(x, r); // 有异常，直接跳出
                break tryComplete;
            }
            r = null;
        }
        try {
            if (c != null && !c.claim())
                return false;
            @SuppressWarnings("unchecked")
            S s = (S) r;
            completeValue(f.apply(s));
        } catch (Throwable ex) {
            completeThrowable(ex);
        }
    }
    return true;
}

static final class UniApply extends UniCompletion {
    Function fn;

    UniApply(Executor executor, CompletableFuture dep, CompletableFuture src,
            Function fn) {
        super(executor, dep, src);
        this.fn = fn;
    }

    final CompletableFuture tryFire(int mode) {
        CompletableFuture d;
        CompletableFuture a;
        if ((d = dep) == null || !d.uniApply(a = src, fn, mode > 0 ? null : this))
            return null;
        dep = null;
        src = null;
        fn = null;
        return d.postFire(a, mode);
    }
}

一样的套路，thenApply/thenApplyAsync -> uniApplyStage -> uniApply -> tryFire -> postFire

thenAccept

public CompletableFuture thenAccept(Consumer action) {
    return uniAcceptStage(null, action);
}

public CompletableFuture thenAcceptAsync(Consumer action) {
    return uniAcceptStage(asyncPool, action);
}

private CompletableFuture uniAcceptStage(Executor e, Consumer f) {
    if (f == null)
        throw new NullPointerException();
    CompletableFuture d = new CompletableFuture();
    if (e != null || !d.uniAccept(this, f, null)) {
        UniAccept c = new UniAccept(e, d, this, f);
        push(c);
        c.tryFire(SYNC);
    }
    return d;
}

final  boolean uniAccept(CompletableFuture a, Consumer f, UniAccept c) {
    Object r;
    Throwable x;
    if (a == null || (r = a.result) == null || f == null)
        return false;
    tryComplete: if (result == null) {
        if (r instanceof AltResult) {
            if ((x = ((AltResult) r).ex) != null) {
                completeThrowable(x, r); // 有异常直接跳出
                break tryComplete;
            }
            r = null;
        }
        try {
            if (c != null && !c.claim())
                return false;
            @SuppressWarnings("unchecked")
            S s = (S) r;
            f.accept(s);
            completeNull();
        } catch (Throwable ex) {
            completeThrowable(ex);
        }
    }
    return true;
}

static final class UniAccept extends UniCompletion {
    Consumer fn;

    UniAccept(Executor executor, CompletableFuture dep, CompletableFuture src, Consumer fn) {
        super(executor, dep, src);
        this.fn = fn;
    }

    final CompletableFuture tryFire(int mode) {
        CompletableFuture d;
        CompletableFuture a;
        if ((d = dep) == null || !d.uniAccept(a = src, fn, mode > 0 ? null : this))
            return null;
        dep = null;
        src = null;
        fn = null;
        return d.postFire(a, mode);
    }
}

thenAccept/thenAcceptAsync -> uniAcceptStage -> uniAccept -> tryFire -> postFire

thenRun

public CompletableFuture thenRun(Runnable action) {
    return uniRunStage(null, action);
}

public CompletableFuture thenRunAsync(Runnable action) {
    return uniRunStage(asyncPool, action);
}

private CompletableFuture uniRunStage(Executor e, Runnable f) {
    if (f == null)
        throw new NullPointerException();
    CompletableFuture d = new CompletableFuture();
    if (e != null || !d.uniRun(this, f, null)) {
        UniRun c = new UniRun(e, d, this, f);
        push(c);
        c.tryFire(SYNC);
    }
    return d;
}

final boolean uniRun(CompletableFuture a, Runnable f, UniRun c) {
    Object r;
    Throwable x;
    if (a == null || (r = a.result) == null || f == null)
        return false;
    if (result == null) {
        if (r instanceof AltResult && (x = ((AltResult) r).ex) != null)
            completeThrowable(x, r);
        else
            try {
                if (c != null && !c.claim())
                    return false;
                f.run();
                completeNull();
            } catch (Throwable ex) {
                completeThrowable(ex);
            }
    }
    return true;
}

static final class UniRun extends UniCompletion {
    Runnable fn;

    UniRun(Executor executor, CompletableFuture dep, CompletableFuture src, Runnable fn) {
        super(executor, dep, src);
        this.fn = fn;
    }

    final CompletableFuture tryFire(int mode) {
        CompletableFuture d;
        CompletableFuture a;
        if ((d = dep) == null || !d.uniRun(a = src, fn, mode > 0 ? null : this))
            return null;
        dep = null;
        src = null;
        fn = null;
        return d.postFire(a, mode);
    }
}

thenRun/thenRunAsync -> uniRunStage -> uniRun -> tryFire -> postFire

thenAcceptBoth

thenAcceptBoth

public  CompletableFuture thenAcceptBoth(CompletionStage other,
        BiConsumer action) {
    return biAcceptStage(null, other, action);
}

public  CompletableFuture thenAcceptBothAsync(CompletionStage other,
        BiConsumer action) {
    return biAcceptStage(asyncPool, other, action);
}

biAcceptStage

private  CompletableFuture biAcceptStage(Executor e, CompletionStage o,
        BiConsumer f) {
    CompletableFuture b;
    if (f == null || (b = o.toCompletableFuture()) == null)
        throw new NullPointerException();
    CompletableFuture d = new CompletableFuture();
    if (e != null || !d.biAccept(this, b, f, null)) {
        BiAccept c = new BiAccept(e, d, this, b, f);
        bipush(b, c);
        c.tryFire(SYNC);
    }
    return d;
}

bipush

final void bipush(CompletableFuture b, BiCompletion c) {
    if (c != null) {
        Object r;
        while ((r = result) == null && !tryPushStack(c)) // a的result还没准备好，c压入栈
            lazySetNext(c, null); // 失败重置c的next域
        if (b != null && b != this && b.result == null) { // b的result也还没准备好
            Completion q = (r != null) ? c : new CoCompletion(c); // 根据a的result决定是否构建CoCompletion, 如果a未结束，则构建一个CoCompletion, CoCompletion最后调用的也是BiCompletion的tryFire
            while (b.result == null && !b.tryPushStack(q)) // 将q压入栈
                lazySetNext(q, null); // 失败重置q的next域
        }
    }
}

CoCompletion

static final class CoCompletion extends Completion {
    BiCompletion base;

    CoCompletion(BiCompletion base) {
        this.base = base;
    }

    final CompletableFuture tryFire(int mode) {
        BiCompletion c;
        CompletableFuture d;
        if ((c = base) == null || (d = c.tryFire(mode)) == null) // 调用的还是BiCompletion的tryFire方法
            return null;
        base = null;
        return d;
    }

    final boolean isLive() {
        BiCompletion c;
        return (c = base) != null && c.dep != null;
    }
}

biAccept

final  boolean biAccept(CompletableFuture a, CompletableFuture b, BiConsumer f,
    BiAccept c) {
    Object r, s;
    Throwable x;
    if (a == null || (r = a.result) == null || b == null || (s = b.result) == null || f == null)
        return false; // a和b都完成了，才会往下走
    tryComplete: if (result == null) {
        if (r instanceof AltResult) {
            if ((x = ((AltResult) r).ex) != null) { // a的异常检查
                completeThrowable(x, r);
                break tryComplete;
            }
            r = null;
        }
        if (s instanceof AltResult) {
            if ((x = ((AltResult) s).ex) != null) { // b的异常检查
                completeThrowable(x, s);
                break tryComplete;
            }
            s = null;
        }
        try {
            if (c != null && !c.claim())
                return false;
            @SuppressWarnings("unchecked")
            R rr = (R) r;
            @SuppressWarnings("unchecked")
            S ss = (S) s;
            f.accept(rr, ss); // 执行任务
            completeNull();
        } catch (Throwable ex) {
            completeThrowable(ex);
        }
    }
    return true;
}

BiAccept

static final class BiAccept extends BiCompletion {
    BiConsumer fn;

    BiAccept(Executor executor, CompletableFuture dep, CompletableFuture src, CompletableFuture snd,
        BiConsumer fn) {
        super(executor, dep, src, snd);
        this.fn = fn;
    }

    final CompletableFuture tryFire(int mode) {
        CompletableFuture d;
        CompletableFuture a;
        CompletableFuture b;
        if ((d = dep) == null || !d.biAccept(a = src, b = snd, fn, mode > 0 ? null : this))
            return null;
        dep = null;
        src = null;
        snd = null;
        fn = null;
        return d.postFire(a, b, mode);
    }
}

abstract static class BiCompletion extends UniCompletion {
    CompletableFuture snd; // second source for action

    BiCompletion(Executor executor, CompletableFuture dep, CompletableFuture src, CompletableFuture snd) {
        super(executor, dep, src);
        this.snd = snd;
    }
}

thenAcceptBoth/thenAcceptBothAsync -> biAcceptStage -> biAccept -> tryFire -> postFire

acceptEither

public CompletableFuture acceptEither(CompletionStage other, Consumer action) {
    return orAcceptStage(null, other, action);
}

public CompletableFuture acceptEitherAsync(CompletionStage other, Consumer action) {
    return orAcceptStage(asyncPool, other, action);
}

private  CompletableFuture orAcceptStage(Executor e, CompletionStage o,
        Consumer f) {
    CompletableFuture b;
    if (f == null || (b = o.toCompletableFuture()) == null)
        throw new NullPointerException();
    CompletableFuture d = new CompletableFuture();
    if (e != null || !d.orAccept(this, b, f, null)) {
        OrAccept c = new OrAccept(e, d, this, b, f);
        orpush(b, c);
        c.tryFire(SYNC);
    }
    return d;
}

final  boolean orAccept(CompletableFuture a, CompletableFuture b, Consumer f,
        OrAccept c) {
    Object r;
    Throwable x;
    if (a == null || b == null || ((r = a.result) == null && (r = b.result) == null) || f == null)
        return false; // a和b有一个完成了就往下走
    tryComplete: if (result == null) {
        try {
            if (c != null && !c.claim())
                return false;
            if (r instanceof AltResult) { // 异常
                if ((x = ((AltResult) r).ex) != null) {
                    completeThrowable(x, r);
                    break tryComplete;
                }
                r = null;
            }
            @SuppressWarnings("unchecked")
            R rr = (R) r;
            f.accept(rr); // 执行
            completeNull();
        } catch (Throwable ex) {
            completeThrowable(ex);
        }
    }
    return true;
}

static final class OrAccept extends BiCompletion {
    Consumer fn;

    OrAccept(Executor executor, CompletableFuture dep, CompletableFuture src, CompletableFuture snd,
            Consumer fn) {
        super(executor, dep, src, snd);
        this.fn = fn;
    }

    final CompletableFuture tryFire(int mode) {
        CompletableFuture d;
        CompletableFuture a;
        CompletableFuture b;
        if ((d = dep) == null || !d.orAccept(a = src, b = snd, fn, mode > 0 ? null : this))
            return null;
        dep = null;
        src = null;
        snd = null;
        fn = null;
        return d.postFire(a, b, mode);
    }
}

final void orpush(CompletableFuture b, BiCompletion c) {
    if (c != null) {
        while ((b == null || b.result == null) && result == null) { // a和b的result都没好，才会考虑入栈
            if (tryPushStack(c)) { // 先入a的栈
                if (b != null && b != this && b.result == null) { // 入a的栈成功，b的result还没好
                    Completion q = new CoCompletion(c); // a还未结束，用c构建CoCompletion
                    while (result == null && b.result == null && !b.tryPushStack(q)) // 再次判断，a和b的result都没好，才会考虑入栈
                    lazySetNext(q, null); // 失败置空q的next域
                }
                break;
            }
            lazySetNext(c, null); // 失败置空c的next域
        }
    }
}

acceptEither/acceptEitherAsync -> orAcceptStage -> orAccept -> tryFire -> postFire

allOf

public static CompletableFuture allOf(CompletableFuture... cfs) {
    return andTree(cfs, 0, cfs.length - 1);
}

static CompletableFuture andTree(CompletableFuture[] cfs, int lo, int hi) { // 将一个数组构建成一棵树，二叉树，动态规划
    CompletableFuture d = new CompletableFuture();
    if (lo > hi) // empty
        d.result = NIL;
    else {
        CompletableFuture a, b;
        int mid = (lo + hi) >>> 1;
        if ((a = (lo == mid ? cfs[lo] : andTree(cfs, lo, mid))) == null
                || (b = (lo == hi ? a : (hi == mid + 1) ? cfs[hi] : andTree(cfs, mid + 1, hi))) == null)
            throw new NullPointerException();
        if (!d.biRelay(a, b)) {
            BiRelay c = new BiRelay<>(d, a, b);
            a.bipush(b, c); // both
            c.tryFire(SYNC);
        }
    }
    return d;
}

static final class BiRelay extends BiCompletion { // for And
    BiRelay(CompletableFuture dep, CompletableFuture src, CompletableFuture snd) {
        super(null, dep, src, snd);
    }

    final CompletableFuture tryFire(int mode) {
        CompletableFuture d;
        CompletableFuture a;
        CompletableFuture b;
        if ((d = dep) == null || !d.biRelay(a = src, b = snd))
            return null;
        src = null;
        snd = null;
        dep = null;
        return d.postFire(a, b, mode);
    }
}

boolean biRelay(CompletableFuture a, CompletableFuture b) {
    Object r, s;
    Throwable x;
    if (a == null || (r = a.result) == null || b == null || (s = b.result) == null)
        return false; // a和b都结束了才往下执行
    if (result == null) {
        if (r instanceof AltResult && (x = ((AltResult) r).ex) != null)
            completeThrowable(x, r);
        else if (s instanceof AltResult && (x = ((AltResult) s).ex) != null)
            completeThrowable(x, s);
        else
            completeNull(); // 辅助结点，什么都不做
    }
    return true;
}

allOf -> andTree -> biRelay -> tryFire -> postFire

anyOf

public static CompletableFuture anyOf(CompletableFuture... cfs) {
    return orTree(cfs, 0, cfs.length - 1);
}

static CompletableFuture orTree(CompletableFuture[] cfs, int lo, int hi) { // 将一个数组构建成一棵树，二叉树，动态规划
    CompletableFuture d = new CompletableFuture();
    if (lo <= hi) {
        CompletableFuture a, b;
        int mid = (lo + hi) >>> 1;
        if ((a = (lo == mid ? cfs[lo] : orTree(cfs, lo, mid))) == null
                || (b = (lo == hi ? a : (hi == mid + 1) ? cfs[hi] : orTree(cfs, mid + 1, hi))) == null)
            throw new NullPointerException();
        if (!d.orRelay(a, b)) {
            OrRelay c = new OrRelay<>(d, a, b);
            a.orpush(b, c);
            c.tryFire(SYNC);
        }
    }
    return d;
}

static final class OrRelay extends BiCompletion { // for Or
    OrRelay(CompletableFuture dep, CompletableFuture src, CompletableFuture snd) {
        super(null, dep, src, snd);
    }

    final CompletableFuture tryFire(int mode) {
        CompletableFuture d;
        CompletableFuture a;
        CompletableFuture b;
        if ((d = dep) == null || !d.orRelay(a = src, b = snd))
            return null;
        src = null;
        snd = null;
        dep = null;
        return d.postFire(a, b, mode);
    }
}

final boolean orRelay(CompletableFuture a, CompletableFuture b) {
    Object r;
    if (a == null || b == null || ((r = a.result) == null && (r = b.result) == null))
        return false; // a和b有一个结束就往下进行
    if (result == null)
        completeRelay(r);
    return true;
}
 
 
anyOf -> orTree -> orRelay -> tryFire -> postFire
 
 
数组构建树
 
 
allOf和anyOf都用到了数组构建成树的策略。
 
 
假设有一个任务Z(虚拟的，什么都不做)，依赖一组任务[A, B, C, D, E, F, G, H]
 
 
对于allOf, 当这组任务都完成时，才会执行Z；对于anyOf, 当这组任务中有任何一个完成，就执行任务Z。
 
 
如果这组任务是数组结构或者链表结构，我们该如何解决呢？遍历数组或者是链表，当任务都完成或者有一个完成时，就执行Z，需要不停地遍历，这是轮询的方法，不合适。
 
 
整个基调是回调，是指，当一个任务完成时，会接着执行所有依赖于它的任务。
 
 
作为一个数组或者链表，该如何应用回调呢？谁在先，谁在后呢？因为不知道哪个任务会先完成，所以没法确定次序。而且这组任务之间也不应该相互依赖，它们只不过都是被Z依赖。
 
 
如果这组任务只有一个的话，那就演变成了X.thenXXX(Z), 如果这组任务有两个的话，allOf -> Both，anyOf -> Either
 
 
如果Z依赖Z1,Z2两个个任务，Z1和Z2依赖Z11,Z12和Z21,Z22四个任务，依次类推，当虚拟的任务的个数达到真实任务的个数的一半时，就让虚拟任务监听真实的任务，动态规划加二叉树，时间复杂度也只是logn级别的。
 
 
static String array2Tree(String[] cfs, int lo, int hi) {
    String d = new String(cfs[lo] + cfs[hi]);
    if (lo <= hi) {
        String a, b;
        int mid = (lo + hi) >>> 1; // 二分
        if (lo == mid) { // a作为左半部分的的结果
            a = cfs[lo]; // 当只有不超过两个元素时，a直接取第一个值
        } else {
            a = array2Tree(cfs, lo, mid);
        }
        if (lo == hi) { // 当只有一个元素的时候，b取a的值
            b = a;
        } else {
            if (hi == mid + 1) { // 右半部分只有两个元素时，b取第二个元素的值
                b = cfs[hi];
            } else {
                b = array2Tree(cfs, mid + 1, hi);
            }
        }
        if (a == null || b == null) {
            throw new NullPointerException();
        }
        System.out.println("[" + a + "][" + b + "]->[" + d + "]");
    }
    return d;
}

 
 
Console
 
 
[A][B]->[AB]
[C][D]->[CD]
[AB][CD]->[AD]
[E][F]->[EF]
[G][H]->[GH]
[EF][GH]->[EH]
[AD][EH]->[AH]

 
 
如下图
 
 
 
 
 
  
 
   
  
   
 
  
 
  
 
 
 
 
对于allOf, Z只要保证Z1和Z2都完成了就行，Z1和Z2分别保证Z11,Z12 和 Z21,Z22都完成了就像，而Z11,Z12,Z21,Z22则分别保证了A-H任务都完成。
 
 
对应anyOf, Z 只要保证Z1和Z2有一个完成了就像，Z1和Z2联合保证了Z11,Z12,Z21,Z22这4个任务只要有一个完成了就行，同理，Z11,Z12,Z21,Z22则联合保证了A-H中有一个任务完成了就行。
 
 
然后，Z就可以执行了，其实Z什么也没做，只是从这组任务里得出一个结果。
 
 
参考：
 https://www.cnblogs.com/Createsequence/p/16963895.html
 
 
https://www.cnblogs.com/aniao/p/aniao_cf.html
 
 
https://blog.csdn.net/PNGYUL/article/details/119838961
 
 
https://blog.csdn.net/qq_33512765/article/details/126427491
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Java并发编程——CompletableFuture源码解析)

        

            

                
    
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
    
                    
    • 
                    
  • Istio pilot-discovery服务发现源码解析（1.13版本）
                        xidianjiapei001
#Istioistio云原生服务发现
                        
    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
    
                    
    • 
                    
  • Java集合类框架源码分析 之 RoleList源码解析 【6】
                        yunzhonghefei
Java集合类源码分析RoleList源码解析
                        
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    
                    
    • 
                    
  • VITS 源码解析2-模型概述
                        迪三
#NN_Audio音频人工智能
                        
    VITs是文本到语音(Text-to-Speech,TTS)任务中最流行的技术之一，其实现思路是将文本语音信息融合到了HiFiGAN潜空间内,通过文本控制HiFiGAN的生成器，输出含文本语义的声音。VITs主要以GAN的方式训练,其生成器G是SynthesizerTrn，判别器D是MPD。VITS的判别器几乎和HiFiGAN一样，生成器则融合了文本、时序、声音三大类模型1.文件概述模型部分包含三
    
                    
    • 
                    
  • Java并发编程-AQS详解及案例实战（上篇）
                        猿与禅
Java技术栈源码分析javaAQS并发编程原理
                        
    文章目录AQS概述AQS的核心概念AQS的工作原理AQS的灵活性使用场景使用指南使用示例AQS的本质:为啥叫做异步队列同步器AQS的核心机制“异步队列”的含义“同步器”的含义总结加锁失败的时候如何借助AQS异步入队阻塞等待AQS的锁队列加锁失败时的处理流程异步入队的机制总结ReentractLock如何设置公平锁策略以及原理设置公平锁策略公平锁的运作原理尝试获取锁释放锁性能与公平性的权衡tryLo
    
                    
    • 
                    
  • RBtree
                        努力的小带土
侯捷老师STLc++蓝桥杯
                        
    终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！-【码炫课堂收费课节选之-红黑树源码解析及手写红黑树】_哔哩哔哩_bilibiliB站的听课记录，并写下如下红黑树c++版本代码，该课程真的史诗级推荐！/*RBtreeNode.h*****/#pragmaonceenum{RED=false,BLACK=true};templateclassRBtreeNode{public://红黑树的左右节点
    
                    
    • 
                    
  • 深入理解Kubernetes：kube-scheduler源码解析
                        mujingluo
kubernetes容器云原生
                        
    Kubernetes的调度器（kube-scheduler）是整个系统中至关重要的组件，它负责将待调度的Pods分配到合适的节点上。本文将深入分析kube-scheduler的源码，揭示其内部工作机制。kube-scheduler的核心功能kube-scheduler的核心功能包括：监听Pod变化：通过KubernetesAPI监听所有未调度的Pods。过滤（Filtering）：根据一系列规则（
    
                    
    • 
                    
  • 【Vesta发号器源码】PropertyMachineIdsProvider
                        DeanChangDM

                        
    Vesta发号器源码解析——PropertyMachineIdsProvider属性配置文件持有Id的模式,没啥东西，比单个的多了一个获取下一个的方法封装实现上略有一点点区别privatelong[]machineIds;privateintcurrentIndex;publiclonggetNextMachineId(){returngetMachineId();}publiclonggetMa
    
                    
    • 
                    
  • SingleFlight模式
                        你这个代码我看不懂
Springpython开发语言
                        
    SingleFlight在Java中实现SingleFlight模式，可以通过使用ConcurrentHashMap和CompletableFuture来管理并发请求。以下是一个示例代码，展示了如何在Java中实现SingleFlight模式：示例代码importjava.util.concurrent.CompletableFuture;importjava.util.concurrent.Co
    
                    
    • 
                    
  • StarRocks分布式元数据源码解析
                        不甚了然
Iceberg知识集StarRocksIceberg数据湖湖仓一体大数据
                        
    1.支持元数据表https://github.com/StarRocks/starrocks/pull/44276/files核心类：LogicalIcebergMetadataTable，Iceberg元数据表，将元数据的各个字段做成表的列，后期可以通过sql操作从元数据获取字段，这个表的组成字段是DataFile相关的字段public static LogicalIcebergMetadata
    
                    
    • 
                    
  • 【Starrocks】建表篇Fe源码解析
                        数算七弦
Starrocks大数据
                        
    Starrocks系统架构简述现在市面上主流的OLAP存算一体架构主要有两类进程：Frontend（FE）和Backend（BE）Frontend一般是用Java写的。主要职责有：接收用户连接请求（MySQL协议层）元数据存储与管理查询语句的解析与查询计划的生成集群管控Backend一般是用C++写的，主要职责有：数据存储与管理查询计划的执行建表语句的执行过程与Mysql协议层交互词法解析语法解析
    
                    
    • 
                    
  • 智能农业设备软件工程师如何集成和管理农业物联网（IoT）平台
                        openwin_top
智能农业设备软件工程师物联网python开发语言深度学习大数据智能农业
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业物联网（IoT）平台涉及多个步骤，包括设备连接、数据收集、数据传输、数据存储、数据分析和展示。以下是详细分析和示例代码展示。1.设备连接和数据收集首先，智能农业设备需要能够与传感器和执
    
                    
    • 
                    
  • 智能农业设备软件工程师如何集成和管理农业设备的远程更新系统
                        openwin_top
智能农业设备软件工程师深度学习大数据物联网人工智能网络智能农业
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业设备的远程更新系统涉及多个技术层面，包括设备固件的安全更新、版本控制、网络通信，以及设备管理平台的开发。下面我们详细分析这些步骤，并提供一个基本的示例代码来展示如何实现这个系统。1.系
    
                    
    • 
                    
  • 智能农业设备软件工程师如何处理设备的远程诊断和修复
                        openwin_top
智能农业设备软件工程师网络智能农业物联网人工智能大数据深度学习
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位处理智能农业设备的远程诊断和修复涉及几个关键步骤，包括设备的数据采集、数据传输、远程诊断、远程控制和修复。以下是详细分析和示例代码：1.数据采集智能农业设备通常配备传感器和控制器，这些设备不断采集环
    
                    
    • 
                    
  • android10 按键音量调节源码解析
                        @OuYang
android
                        
    /frameworks/base/services/core/java/com/android/server/policy/PhoneWindowManager.javastaticIAudioServicegetAudioService(){IAudioServiceaudioService=IAudioService.Stub.asInterface(ServiceManager.checkS
    
                    
    • 
                    
  • android10 Settings源码解析
                        @OuYang
android
                        
    /packages/apps/Settings/AndroidManifest.xml.................................................................................activity-alias是Android里为了重复使用Activity而设计的。对于activity-alias标签，它有一个属性叫android:
    
                    
    • 
                    
  • MyBatis 源码解析：XMLScriptBuilder 工作机制
                        捕风捉你
MyBatis源码解读mybatisjava
                        
    摘要MyBatis提供了强大的动态SQL功能，它通过解析XML配置文件中的动态SQL标签（如、、等），来实现灵活的SQL生成。而XMLScriptBuilder类则负责解析这些XML配置并生成最终的SQL语句。本文将详细解析XMLScriptBuilder的工作机制，并通过自定义实现来帮助您深入理解该类的功能。前言MyBatis中的动态SQL功能是通过解析XML配置文件实现的。XML文件中包含了动
    
                    
    • 
                    
  • c#视觉应用开发中如何使用Emgu CV在C#中进行图像处理？
                        openwin_top
C#视觉应用开发问题系列c#图像处理开发语言
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位EmguCV是OpenCV的.NET包装器，可以让开发者在.NET语言（如C#）中使用OpenCV的功能进行图像处理。在进行图像处理时，EmguCV提供了丰富的API可以使用。以下是使用EmguCV
    
                    
    • 
                    
  • Java并发编程：线程生命周期
                        乐只乐之
Java并发编程java职场和发展后端
                        
    Java并发编程专栏文章收录于Java并发编程专栏线程生命周期  线程是Java并发编程的核心概念，理解线程生命周期对于编写高效的并发程序至关重要。本文将详细介绍Java线程的六种状态以及状态之间的转换关系，帮助读者更好地理解线程的行为。  在Java中JVM将线程按照生命周期划分为了四大种类：运行、等待、阻塞和结束，其中运行分为就绪（READY）和运行中中（RUNNING），阻塞分为等待（WAI
    
                    
    • 
                    
  • Elasticsearch——配置详解
                        smart哥
elasticsearch专题elasticsearch搜索引擎
                        
    作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！阶段1、深入多线程阶段2、深入多线程设计模式阶段3、深入juc源码解析阶段4、深入jdk其余源码解析阶段5、深入jvm源码解析码哥源码部分码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场
    
                    
    • 
                    
  • SpringBoot高并发！java分布式开发面试题
                        spring面试题
程序员面试后端java
                        
    正文梳理知识点，是快速提升技术的关键前面讲过，快速提升自己的技术硬实力其实是有方法的。大致就是梳理知识点+夯实基础+进阶深入学习+实战，下面我会一点点跟大家剖析，本文干货满满，大家仔细阅读。梳理知识后，夯实基础乃是刚需：深入进阶学习（28个主流Java知识点“一网打尽”）1、并发编程Java并发编程是整个Java开发体系中最难以理解，但也是最重要的知识点之一，一旦掌握你一定在市场上供不应求。Jav
    
                    
    • 
                    
  • Java并发编程(五)—ReetrantLock详解及应用
                        echola_mendes
Java并发编程java开发语言
                        
    目录一、ReetrantLock的特性1、非阻塞获取锁2、带超时的锁获取:3、锁的公平性4、锁的可中断性5、Condition条件变量6、锁的可重入性可重入锁不可重入锁7、性能优化二、ReentrantLock和Synchronized的区别1、语法和使用方式2、锁的获取和释放3、高级特性4、条件变量5、性能总结三、ReentrantLock使用场景之前的文章Java并发编程(四)—synchro
    
                    
    • 
                    
  • Eventbus3.0源码解析
                        超威蓝猫l

                        
    根据官方demo首先你需要先在activity中注册EventBus.getDefault().register(this);register所以我们先从getDefault方法开始看起/**Conveniencesingletonforappsusingaprocess-wideEventBusinstance.*/publicstaticEventBusgetDefault(){EventBu
    
                    
    • 
                    
  • 前端宝典之三：React源码解析之Fiber架构
                        桃子叔叔
大厂进阶前端深度解析系列react.js架构javascript
                        
    本文主要内容：1、ReactConcurrent2、React15架构3、React16架构4、Fiber架构5、任务调度循环和fiber构造循环区别一、ReactConcurrentReact在解决CPU卡顿是会用到ReactConcurrent的概念，它是React中的一个重要特性和模块，主要的特点和原理如下一、主要特点和优势1、时间切片（TimeSlicing）允许将长时间运行的任务分割成小
    
                    
    • 
                    
  • Java修炼之道--并发编程
                        weixin_30312557
运维面试操作系统
                        
    原作地址：https://github.com/frank-lam/2019_campus_apply前言在本文将总结多线程并发编程中的常见面试题，主要核心线程生命周期、线程通信、并发包部分。主要分成“并发编程”和“面试指南”两部分，在面试指南中将讨论并发相关面经。参考资料：《Java并发编程实战》第一部分：并发编程1.线程状态转换新建（New）创建后尚未启动。可运行（Runnable）可能正在运
    
                    
    • 
                    
  • 深入理解 `ThreadLocal` 的 `set` 和 `get` 方法
                        CodeDunkster
javajvm开发语言
                        
    ThreadLocal类在Java并发编程中非常有用，它允许每个线程拥有自己独立的变量副本。本文将详细讲解ThreadLocal的set和get方法的工作原理，并通过示例代码说明线程如何使用多个ThreadLocal实例。ThreadLocal的set和get方法原理set方法ThreadLocal的set方法用于将值存储到当前线程的ThreadLocalMap中。其主要步骤如下：获取当前线程：s
    
                    
    • 
                    
  • Java集合之HashSet源码解析
                        气宇轩昂固执狂
JAVA面试笔试通关指南java开发语言HashSetHashSet源码
                        
    一、HashSet概述：1、HashSet底层实现实际上就是利用HashMap的键（Key）来存储对象，原HashMap的键key的位置存放对象，值value的位置存放空的Object对象作为虚拟值；2、增加和删除都是直接调用HashMap的方法来实现的，没有修改和具体的查询方法，获取值只能通过iterator方法来迭代，迭代方法也是建立在HashMap的键的迭代方法上的。相关HashSet的操作
    
                    
    • 
                    
  • Spring之AOP底层源码解析（上）
                        阿立聊代码
spring代理模式
                        
    动态代理代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。比如，现在存在一个UserService类：public class UserService  { public void test() {  System.out.println("test..."); }}此时，我们new一个UserService对象，然后执行test()方法，结果是
    
                    
    • 
                    
  • Spring Boot自动配置源码解析
                        一休哥助手
springbootjava数据库
                        
    一、自动配置概述1.1什么是自动配置SpringBoot的自动配置是一种能够根据类路径中的依赖、配置文件中的属性以及其他条件，自动配置Spring应用上下文的功能。它通过扫描项目中的类和配置文件，判断哪些组件需要自动装配，从而减少了手动编写配置代码的繁琐过程。1.2自动配置的优点减少配置工作量：自动配置能够帮助开发者快速启动一个Spring应用，而不必担心各种复杂的XML或Java配置。智能化配置
    
                    
    • 
                                
  • 辗转相处求最大公约数
                                    沐刃青蛟
C++漏洞
                                    
    无言面对”江东父老“了，接触编程一年了，今天发现还不会辗转相除法求最大公约数。惭愧惭愧！ 
  
为此，总结一下以方便日后忘了好查找。 
  
1.输入要比较的两个数a,b 
  
忽略：2.比较大小（因为后面要的是大的数对小的数做%操作） 
  
3.辗转相除（用循环不停的取余，如a%b,直至b=0） 
  
4.最后的a为两数的最大公约数 
&
    
                                
    • 
                                
  • F5负载均衡会话保持技术及原理技术白皮书
                                    bijian1013
F5负载均衡
                                    
    一.什么是会话保持？        在大多数电子商务的应用系统或者需要进行用户身份认证的在线系统中，一个客户与服务器经常经过好几次的交互过程才能完成一笔交易或者是一个请求的完成。由于这几次交互过程是密切相关的，服务器在进行这些交互过程的某一个交互步骤时，往往需要了解上一次交互过程的处理结果，或者上几步的交互过程结果，服务器进行下
    
                                
    • 
                                
  • Object.equals方法：重载还是覆盖
                                    Cwind
javagenericsoverrideoverload
                                    
    本文译自StackOverflow上对此问题的讨论。 
原问题链接 
  
在阅读Joshua Bloch的《Effective Java（第二版）》第8条“覆盖equals时请遵守通用约定”时对如下论述有疑问： 
“不要将equals声明中的Object对象替换为其他的类型。程序员编写出下面这样的equals方法并不鲜见，这会使程序员花上数个小时都搞不清它为什么不能正常工作：” 
pu
    
                                
    • 
                                
  • 初始线程
                                    15700786134

                                    
          暑假学习的第一课是讲线程，任务是是界面上的一条线运动起来。 
  
  
       既然是在界面上，那必定得先有一个界面，所以第一步就是，自己的类继承JAVA中的JFrame，在新建的类中写一个界面，代码如下： 
public class ShapeFr
    
                                
    • 
                                
  • Linux的tcpdump
                                    被触发
tcpdump
                                    
    用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支 持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。 
 
实用命令实例 
默认启动 
tcpdump 
普通情况下，直
    
                                
    • 
                                
  • 安卓程序listview优化后还是卡顿
                                    肆无忌惮_
ListView
                                    
    最近用eclipse开发一个安卓app，listview使用baseadapter，里面有一个ImageView和两个TextView。使用了Holder内部类进行优化了还是很卡顿。后来发现是图片资源的问题。把一张分辨率高的图片放在了drawable-mdpi文件夹下，当我在每个item中显示，他都要进行缩放，导致很卡顿。解决办法是把这个高分辨率图片放到drawable-xxhdpi下。 
&nb
    
                                
    • 
                                
  • 扩展easyUI tab控件，添加加载遮罩效果
                                    知了ing
jquery
                                    
    (function () {  
    $.extend($.fn.tabs.methods, {  
        //显示遮罩  
        loading: function (jq, msg) {  
            return jq.each(function () {  
                var panel = $(this).tabs(&
    
                                
    • 
                                
  • gradle上传jar到nexus
                                    矮蛋蛋
gradle
                                    
    原文地址： 
https://docs.gradle.org/current/userguide/maven_plugin.html 
configurations { 
    deployerJars 
} 
 
dependencies { 
    deployerJars "org.apache.maven.wagon
    
                                
    • 
                                
  • 千万条数据外网导入数据库的解决方案。
                                    alleni123
sqlmysql
                                    
    从某网上爬了数千万的数据，存在文本中。 
然后要导入mysql数据库。 
 
悲剧的是数据库和我存数据的服务器不在一个内网里面。。 
 
 
ping了一下， 19ms的延迟。 
 
于是下面的代码是没用的。 
 

ps = con.prepareStatement(sql);
	ps.setString(1, info.getYear())............;
			ps.exec
    
                                
    • 
                                
  • JAVA IO InputStreamReader和OutputStreamReader
                                    百合不是茶
JAVA.io操作 字符流
                                    
    这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励 我会更加的去学 加油！： 
JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流 
  
字节流和字符的难点：a,怎么将读到的数据
    
                                
    • 
                                
  • MO、MT解读
                                    bijian1013
GSM
                                    
    MO= Mobile originate，上行，即用户上发给SP的信息。MT= Mobile Terminate，下行，即SP端下发给用户的信息； 
上行:mo提交短信到短信中心下行:mt短信中心向特定的用户转发短信，你的短信是这样的，你所提交的短信，投递的地址是短信中心。短信中心收到你的短信后，存储转发，转发的时候就会根据你填写的接收方号码寻找路由，下发。在彩信领域是一样的道理。下行业务：由SP
    
                                
    • 
                                
  • 五个JavaScript基础问题
                                    bijian1013
JavaScriptcallapplythisHoisting
                                    
    下面是五个关于前端相关的基础问题，但却很能体现JavaScript的基本功底。 
问题1：Scope作用范围 
考虑下面的代码：  
(function() {
   var a = b = 5;
})();
console.log(b); 
什么会被打印在控制台上？  
回答： 
        上面的代码会打印 5。 
&nbs
    
                                
    • 
                                
  • 【Thrift二】Thrift Hello World
                                    bit1129
Hello world
                                    
    本篇，不考虑细节问题和为什么，先照葫芦画瓢写一个Thrift版本的Hello World，了解Thrift RPC服务开发的基本流程 
  
1. 在Intellij中创建一个Maven模块，加入对Thrift的依赖，同时还要加上slf4j依赖，如果不加slf4j依赖，在后面启动Thrift Server时会报错 
        <dependency>
        
    
                                
    • 
                                
  • 【Avro一】Avro入门
                                    bit1129
入门
                                    
    本文的目的主要是总结下基于Avro Schema代码生成，然后进行序列化和反序列化开发的基本流程。需要指出的是，Avro并不要求一定得根据Schema文件生成代码，这对于动态类型语言很有用。 
  1. 添加Maven依赖 
  
<?xml version="1.0" encoding="UTF-8"?>
<proj
    
                                
    • 
                                
  • 安装nginx+ngx_lua支持WAF防护功能
                                    ronin47

                                    
    需要的软件:LuaJIT-2.0.0.tar.gz                   nginx-1.4.4.tar.gz          &nb
    
                                
    • 
                                
  • java-5.查找最小的K个元素-使用最大堆
                                    bylijinnan
java
                                    
    
import java.util.Arrays;
import java.util.Random;


public class MinKElement {

	/**
	 * 5.最小的K个元素
	 * I would like to use MaxHeap.
	 * using QuickSort is also OK
	 */
	public static void
    
                                
    • 
                                
  • TCP的TIME-WAIT
                                    bylijinnan
socket
                                    
    原文连接： 
http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html 
 
以下为对原文的阅读笔记 
 
说明： 
主动关闭的一方称为local end，被动关闭的一方称为remote end 
本地IP、本地端口、远端IP、远端端口这一“四元组”称为quadruplet，也称为socket 
 
1、TIME_WA
    
                                
    • 
                                
  • jquery ajax 序列化表单
                                    coder_xpf
Jquery ajax 序列化
                                    
      
 checkbox 如果不设定值，默认选中值为on；设定值之后，选中则为设定的值 
  
<input type="checkbox" name="favor" id="favor" checked="checked"/>
$("#favor&quo
    
                                
    • 
                                
  • Apache集群乱码和最高并发控制
                                    cuisuqiang
apachetomcat并发集群乱码
                                    
    都知道如果使用Http访问，那么在Connector中增加URIEncoding即可，其实使用AJP时也一样，增加useBodyEncodingForURI和URIEncoding即可。 
最大连接数也是一样的，增加maxThreads属性即可，如下，配置如下： 
<Connector maxThreads="300" port="8019" prot
    
                                
    • 
                                
  • websocket
                                    dalan_123
websocket
                                    
    一、低延迟的客户端-服务器 和 服务器-客户端的连接 
很多时候所谓的http的请求、响应的模式，都是客户端加载一个网页，直到用户在进行下一次点击的时候，什么都不会发生。并且所有的http的通信都是客户端控制的，这时候就需要用户的互动或定期轮训的，以便从服务器端加载新的数据。 
  通常采用的技术比如推送和comet（使用http长连接、无需安装浏览器安装插件的两种方式：基于ajax的长
    
                                
    • 
                                
  • 菜鸟分析网络执法官
                                    dcj3sjt126com
网络
                                    
      
最近在论坛上看到很多贴子在讨论网络执法官的问题。菜鸟我正好知道这回事情.人道"人之患好为人师" 手里忍不住,就写点东西吧. 我也很忙.又没有MM,又没有MONEY....晕倒有点跑题. 
OK,闲话少说,切如正题. 要了解网络执法官的原理. 就要先了解局域网的通信的原理. 
前面我们看到了.在以太网上传输的都是具有以太网头的数据包. 
    
                                
    • 
                                
  • Android相对布局属性全集
                                    dcj3sjt126com
android
                                    
    RelativeLayout布局android:layout_marginTop="25dip" //顶部距离android:gravity="left" //空间布局位置android:layout_marginLeft="15dip //距离左边距 
// 相对于给定ID控件android:layout_above 将该控件的底部置于给定ID的
    
                                
    • 
                                
  • Tomcat内存设置详解
                                    eksliang
jvmtomcattomcat内存设置
                                    
    Java内存溢出详解 
  
一、常见的Java内存溢出有以下三种： 
  
1. java.lang.OutOfMemoryError: Java heap space ----JVM Heap（堆）溢出JVM在启动的时候会自动设置JVM Heap的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)不可超过物理内存。 
可以利用JVM提
    
                                
    • 
                                
  • Java6 JVM参数选项
                                    greatwqs
javaHotSpotjvmjvm参数JVM Options
                                    
    Java 6 JVM参数选项大全（中文版）  
  
作者：Ken Wu 
Email: [email protected] 
转载本文档请注明原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！ 
  
本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Opt
    
                                
    • 
                                
  • weblogic创建JMC
                                    i5land
weblogicjms
                                    
    进入 weblogic控制太 
1.创建持久化存储 
 --Services--Persistant Stores--new--Create FileStores--name随便起--target默认--Directory写入在本机建立的文件夹的路径--ok 
 
2.创建JMS服务器 
 --Services--Messaging--JMS Servers--new--name随便起--Pers
    
                                
    • 
                                
  • 基于 DHT 网络的磁力链接和BT种子的搜索引擎架构
                                    justjavac
DHT
                                    
    上周开发了一个磁力链接和 BT 种子的搜索引擎 {Magnet & Torrent}，本文简单介绍一下主要的系统功能和用到的技术。 
系统包括几个独立的部分： 
 
  使用 Python 的 Scrapy 框架开发的网络爬虫，用来爬取磁力链接和种子；  
  使用 PHP CI 框架开发的简易网站；  
  搜索引擎目前直接使用的 MySQL，将来可以考虑使
    
                                
    • 
                                
  • sql添加、删除表中的列
                                    macroli
sql
                                    
    添加没有默认值：alter table Test add BazaarType char(1) 
有默认值的添加列：alter table Test add BazaarType char(1) default(0) 
删除没有默认值的列：alter table Test drop COLUMN BazaarType 
删除有默认值的列：先删除约束（默认值）alter table Test DRO
    
                                
    • 
                                
  • PHP中二维数组的排序方法
                                    abc123456789cba
排序二维数组PHP
                                    
    <?php/*** @package     BugFree* @version     $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $*** Sort an two-dimension array by some level 
    
                                
    • 
                                
  • hive优化之------控制hive任务中的map数和reduce数
                                    superlxw1234
hivehive优化
                                    
    一、    控制hive任务中的map数:  1.    通常情况下，作业会通过input的目录产生一个或者多个map任务。  主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小(目前为128M, 可在hive中通过set dfs.block.size;命令查看到，该参数不能自定义修改)；2. 
    
                                
    • 
                                
  • Spring Boot 1.2.4 发布
                                    wiselyman
spring boot
                                    
    Spring Boot 1.2.4已于6.4日发布，repo.spring.io and Maven Central可以下载(推荐使用maven或者gradle构建下载)。 
  
这是一个维护版本，包含了一些修复small number of fixes,建议所有的用户升级。 
  
Spring Boot 1.3的第一个里程碑版本将在几天后发布，包含许多
    
                                
    •