CompletableFuture实现异步编排

为什么需要异步执行？

场景：电商系统中获取一个完整的商品信息可能分为以下几步：①获取商品基本信息 ②获取商品图片信息 ③获取商品促销活动信息 ④获取商品各种类的基本信息 等操作，如果使用串行方式去执行这些操作，假设每个操作执行1s，那么用户看到完整的商品详情就需要4s的时间，如果使用并行方式执行这些操作，可能只需要1s就可以完成。所以这就是异步执行的好处。

JDK5的Future接口

Future接口用于代表异步计算的结果，通过Future接口提供的方法可以查看异步计算是否执行完成，或者等待执行结果并获取执行结果，同时还可以取消执行。

列举Future接口的方法：

  • get()：获取任务执行结果，如果任务还没完成则会阻塞等待直到任务执行完成。如果任务被取消则会抛出CancellationException异常，如果任务执行过程发生异常则会抛出ExecutionException异常，如果阻塞等待过程中被中断则会抛出InterruptedException异常。
  • get(long timeout,Timeunit unit)：带超时时间的get()方法，如果阻塞等待过程中超时则会抛出TimeoutException异常。
  • cancel()：用于取消异步任务的执行。如果异步任务已经完成或者已经被取消，或者由于某些原因不能取消，则会返回false。如果任务还没有被执行，则会返回true并且异步任务不会被执行。如果任务已经开始执行了但是还没有执行完成，若mayInterruptIfRunning为true，则会立即中断执行任务的线程并返回true，若mayInterruptIfRunning为false，则会返回true且不会中断任务执行线程。
  • isCanceled()：判断任务是否被取消，如果任务在结束(正常执行结束或者执行异常结束)前被取消则返回true，否则返回false。
  • isDone()：判断任务是否已经完成，如果完成则返回true，否则返回false。需要注意的是：任务执行过程中发生异常、任务被取消也属于任务已完成，也会返回true。

使用Future接口和Callable接口实现异步执行：

public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executorService = Executors.newFixedThreadPool(4);
    // 获取商品基本信息（可以使用Lambda表达式简化Callable接口，这里为了便于观察不使用）
    Future future1 = executorService.submit(new Callable() {
        @Override
        public String call() throws Exception {
            return "获取到商品基本信息";
        }
    });
    // 获取商品图片信息
    Future future2 = executorService.submit(new Callable() {
        @Override
        public String call() throws Exception {
            return "获取商品图片信息";
        }
    });
    // 获取商品促销信息
    Future future3 = executorService.submit(new Callable() {
        @Override
        public String call() throws Exception {
            return "获取商品促销信息";
        }
    });
    // 获取商品各种类基本信息
    Future future4 = executorService.submit(new Callable() {
        @Override
        public String call() throws Exception {
            return "获取商品各种类基本信息";
        }
    });
        // 获取结果
    try {
        System.out.println(future1.get());
        System.out.println(future2.get());
        System.out.println(future3.get());
        System.out.println(future4.get());
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }finally {
        executorService.shutdown();
    }
}
既然Future可以实现异步执行并获取结果，为什么还会需要CompletableFuture?

简述一下Future接口的弊端：

  • 不支持手动完成

    • 当提交了一个任务，但是执行太慢了，通过其他路径已经获取到了任务结果，现在没法把这个任务结果通知到正在执行的线程，所以必须主动取消或者一直等待它执行完成。

  • 不支持进一步的非阻塞调用

    • 通过Future的get()方法会一直阻塞到任务完成，但是想在获取任务之后执行额外的任务，因为 Future 不支持回调函数，所以无法实现这个功能。

  • 不支持链式调用

    • 对于Future的执行结果，想继续传到下一个Future处理使用，从而形成一个链式的pipline调用，这在 Future中无法实现。

  • 不支持多个 Future 合并

    • 比如有10个Future并行执行，想在所有的Future运行完毕之后，执行某些函数，是无法通过Future实现的。

  • 不支持异常处理

    • Future的API没有任何的异常处理的api，所以在异步运行时，如果出了异常问题不好定位。

使用Future接口可以通过get()阻塞式获取结果或者通过轮询＋isDone()非阻塞式获取结果，但是前一种方法会阻塞，后一种会耗费CPU资源，所以JDK的Future接口实现异步执行对获取结果不太友好，所以在JDK8时推出了CompletableFuture实现异步编排。

CompletableFuture的使用

CompletableFuture概述

JDK8中新增加了一个包含50个方法左右的类CompletableFuture，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。

public class CompletableFuture implements Future, CompletionStage

CompletableFuture类实现了Future接口和CompletionStage接口，即除了可以使用Future接口的所有方法之外，CompletionStage接口提供了更多方法来更好的实现异步编排，并且大量的使用了JDK8引入的函数式编程概念。后面会细致的介绍常用的API。

① 创建CompletableFuture的方式

  1. 使用new关键字创建
// 无返回结果
CompletableFuture completableFuture = new CompletableFuture<>();
// 已知返回结果
CompletableFuture completableFuture = new CompletableFuture<>("result");
// 已知返回结果（底层其实也是带参数的构造器赋值）
CompletableFuture completedFuture = CompletableFuture.completedFuture("result");

创建一个返回结果类型为String的CompletableFuture，可以使用Future接口的get()方法获取该值（同样也会阻塞）。

可以使用无参构造器返回一个没有结果的CompletableFuture，也可以通过构造器的传参CompletableFuture设置好返回结果，或者使用CompletableFuture.completedFuture(U value)构造一个已知结果的CompletableFuture。

  1. 使用CompletableFuture类的静态工厂方法（常用）
  1. runAsync() 无返回值
// 使用默认线程池
public static CompletableFuture runAsync(Runnable runnable)
// 使用自定义线程池（推荐）
public static CompletableFuture runAsync(Runnable runnable,Executor executor)

runAsync()方法的参数是Runnable接口，这是一个函数式接口，不允许返回值。当需要异步操作且不关心返回结果的时候可以使用runAsync()方法。

// 例子
public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(4);
    try {
        // 通过Lambda表达式实现Runnable接口
        CompletableFuture.runAsync(()-> System.out.println("获取商品基本信息成功"), executor).get();
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }finally {
        executor.shutdown();
    }
}
  1. supplyAsync() 有返回值
// 使用默认线程池
public static  CompletableFuture supplyAsync(Supplier supplier)
// 使用自定义线程池（推荐）
public static  CompletableFuture supplyAsync(Supplier supplier,Executor executor)

supplyAsync()方法的参数是Supplier供给型接口（无参有返回值），这也是一个函数式接口，U是返回结果值的类型。当需要异步操作且关心返回结果的时候,可以使用supplyAsync()方法。

// 例子
public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(4);
    try {
        // 通过Lambda表达式实现执行内容，并返回结果通过CompletableFuture接收
        CompletableFuture completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("获取商品信息成功");
            return "信息";
        }, executor);
        // 输出结果
        System.out.println(completableFuture.get());
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }finally {
        executor.shutdown();
    }
}
关于第二个参数Executor executor说明

在没有指定第二个参数（即没有指定线程池）时，CompletableFuture直接使用默认的ForkJoinPool.commonPool()作为它的线程池执行异步代码。

在实际生产中会使用自定义的线程池来执行异步代码，具体可以参考另一篇文章深入理解线程池ThreadPoolExecutor - 掘金 (juejin.cn)，里面的第二节有生产中怎么创建自定义线程的例子，可以参考一下。

② 获得异步执行结果

  1. get() 阻塞式获取执行结果
public T get() throws InterruptedException, ExecutionException

该方法调用后如果任务还没完成则会阻塞等待直到任务执行完成。如果任务执行过程发生异常则会抛出ExecutionException异常，如果阻塞等待过程中被中断则会抛出InterruptedException异常。

  1. get(long timeout, TimeUnit unit) 带超时的阻塞式获取执行结果
public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException

该方法调用后如果如果任务还没完成则会阻塞等待直到任务执行完成或者超出timeout时间，如果阻塞等待过程中超时则会抛出TimeoutException异常。

  1. getNow(T valueIfAbsent) 立刻获取执行结果
public T getNow(T valueIfAbsent)

该方法调用后，会立刻获取结果不会阻塞等待。如果任务完成则直接返回执行完成后的结果，如果任务没有完成，则返回调用方法时传入的参数valueIfAbsent值。

  1. join() 不抛异常的阻塞时获取执行结果
public T join()

该方法和get()方法作用一样，只是不会抛出异常。

  1. complete(T value) 主动触发计算，返回异步是否执行完毕
public boolean complete(T value)

该方法调用后，会主动触发计算结果，如果此时异步执行并没有完成（此时boolean值返回true），则通过get()拿到的数据会是complete()设置的参数value值，如果此时异步执行已经完成（此时boolean值返回false），则通过get()拿到的就是执行完成的结果。

// 例子
public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(4);
    try {
        // 通过Lambda表达式实现执行内容，并返回结果通过CompletableFuture接收
        CompletableFuture completableFuture = CompletableFuture.supplyAsync(() -> {
            // 休眠2秒，使得异步执行变慢，会导致主动触发计算先执行，此时返回的get就是555
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
            return 666;
        }, executor);
        // 主动触发计算，判断异步执行是否完成
        System.out.println(completableFuture.complete(555));
        // 输出结果
        System.out.println(completableFuture.get());
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }finally {
        executor.shutdown();
    }
}

/**
输出结果:
    true
    555
**/

③ 对执行结果进行处理

whenComplete 等待前面任务执行完再执行当前处理 
public CompletableFuture whenComplete(
        BiConsumer action)

在创建好的初始任务或者是上一个任务后通过链式调用该方法，会在之前任务执行完成后继续执行whenComplete里的内容（whenComplete传入的action只是对之前任务的结果进行处理），即使用该方法可以避免前面说到的Future接口的问题，不再需要通过阻塞或者轮询的方式去获取结果，而是通过调用该方法等任务执行完毕自动调用。

该方法的参数为BiConsumer action消费者接口，可以接收两个参数，一个是任务执行完的结果，一个是执行任务时的异常。

// 例子
public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(4);
    try {
        CompletableFuture.supplyAsync(() -> 666, executor)
                .whenComplete((res, ex) -> System.out.println("任务执行完毕，结果为" + res + " 异常为" + ex)
                );
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        executor.shutdown();
    }
}

/**
输出结果:
    任务执行完毕，结果为666 异常为null
**/
除了上述的方法外，还有一些类似的方法如XXXAsync()或者是XXXAsync(XX,Executor executor),对于这些方法，这里统一说明，后续文章中将不会再列举 
public CompletableFuture whenCompleteAsync(
        BiConsumer action)

public CompletableFuture whenCompleteAsync(
        BiConsumer action, Executor executor)

XXXAsync()：表示上一个任务执行完成后，不会再使用之前任务中的线程，而是重新使用从默认线程（ForkJoinPool 线程池）中重新获取新的线程执行当前任务。

XXXAsync(XX,Executor executor)：表示不会沿用之前任务的线程，而是使用自己第二个参数指定的线程池重新获取线程执行当前任务。

④ 对执行结果进行消费

  1. thenRun 前面任务执行完后执行当前任务，不关心前面任务的结果，也没返回值
public CompletableFuture thenRun(Runnable action)

CompletableFuture.supplyAsync(actionA).thenRun(actionB)像这样链式调用该方法表示：执行任务A完成后接着执行任务B，但是任务B不需要A的结果，并且执行完任务B也不会返回结果。

thenRun(Runnable action)的参数为Runnable接口即没有传入参数。

// 例子
public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(4);
    try {
        CompletableFuture.supplyAsync(() -> 666, executor)
                    .thenRun(() -> System.out.println("我都没有参数怎么拿到之前的结果，我也没有返回值。")
                );
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        executor.shutdown();
    }
}

/**
输出结果:
    我都没有参数怎么拿到之前的结果，我也没有返回值。
**/
  1. thenAccept 前面任务执行完后执行当前任务，消费前面的结果，没有返回值
public CompletableFuture thenAccept(Consumer action)

CompletableFuture.supplyAsync(actionA).thenRun(actionB)像这样链式调用该方法表示：执行任务A完成后接着执行任务B，而且任务B需要A的结果，但是执行完任务B不会返回结果。

thenAccept(Consumer action)的参数为消费者接口，即可以传入一个参数，该参数为上一个任务的执行结果。

// 例子
public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(4);
    try {
        CompletableFuture.supplyAsync(() -> 666, executor)
                .thenAccept((res) -> System.out.println("我能拿到上一个的结果" + res + ",但是我没法传出去。")
                );
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        executor.shutdown();
    }
}

/**
输出结果:
    我能拿到上一个的结果666,但是我没法传出去。
**/
  1. thenApply 前面任务执行完后执行当前任务，消费前面的结果，具有返回值
public  CompletableFuture thenApply(Function fn)

CompletableFuture.supplyAsync(actionA).thenRun(actionB)像这样链式调用该方法表示：执行任务A完成后接着执行任务B，而且任务B需要A的结果，并且执行完任务B需要有返回结果。

thenApply(Function fn)的参数为函数式接口，即可以传入一个参数类型为T，该参数是上一个任务的执行结果，并且函数式接口需要有返回值,类型为U。

// 例子
public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(4);
    try {
        CompletableFuture.supplyAsync(() -> 666, executor)
                .thenApply((res) -> {
                        System.out.println("我能拿到上一个的结果" + res + "并且我要将结果传出去");
                        return res;
                    }
                ).whenComplete((res, ex) -> System.out.println("结果" + res));
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        executor.shutdown();
    }
}
/**
输出结果:
    我能拿到上一个的结果666并且我要将结果传出去
    结果666
**/

⑤ 异常处理

  1. exceptionally 异常捕获，只消费前面任务中出现的异常信息，具有返回值
public CompletableFuture exceptionally(Function fn)

可以通过链式调用该方法来获取异常信息，并且具有返回值。如果某一个任务出现异常被exceptionally捕获到则剩余的任务将不会再执行。类似于Java异常处理的catch。

exceptionally(Function fn)的参数是函数式接口，具有一个参数以及返回值，该参数为前面任务的异常信息。

// 例子
public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(4);
    try {
        CompletableFuture.supplyAsync(() -> {
                    if (Math.random() < 0.5) throw new RuntimeException("error");
                    return 666;
                }, executor)
                .thenApply((res) -> {
                    System.out.println("不出现异常，结果为" + res);
                    return res;
                }).exceptionally((ex) -> {
                    ex.printStackTrace();
                    return -1;
                });
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        executor.shutdown();
    }
}

/**
输出结果:
// 这是不出现异常的情况
不出现异常，结果为666

// 这是出现异常的情况
java.util.concurrent.CompletionException: java.lang.RuntimeException: error
        at java.base/java.util.concurrent.CompletableFuture.encodeThrowable(CompletableFuture.java:314)
        at java.base/java.util.concurrent.CompletableFuture.completeThrowable(CompletableFuture.java:319)
        at java.base/java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1702)
        at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)
        at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)
        at java.base/java.lang.Thread.run(Thread.java:834)
Caused by: java.lang.RuntimeException: error
        at com.xqsr.review.thread.ThreadTest.lambda$main$0(ThreadTest.java:15)
        at java.base/java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1700)
        ... 3 more
**/
  1. handle 异常处理，消费前面的结果及异常信息，具有返回值，不会中断后续任务
public  CompletableFuture handle(BiFunction fn)

可以通过链式调用该方法可以跟thenApply()一样可以消费前面任务的结果并完成自己任务内容，并且具有返回值。不同之处在于出现异常也可以接着往下执行，根据异常参数做进一步处理。

handle(BiFunction fn)的参数是消费者接口，一个参数是任务执行结果，一个是异常信息，并且具有返回值。

// 例子
public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(4);
    try {
        CompletableFuture.supplyAsync(() -> 666, executor)
                .thenApply((res) -> {
                    if (Math.random() < 0.5) throw new RuntimeException("error");
                    return res;
                }).handle((res, ex) -> {
                    System.out.println("结果" + res + "(null表示之前出现异常导致结果无法传过来)");
                    return res == null ? -1 : res;
                }).thenApply((res) -> {
                    System.out.println("结果为" + res + "(-1表示之前出现异常，经过handler使得结果处理成-1)");
                    return res;
                }).exceptionally((ex) -> {
                    ex.printStackTrace();
                    return -1;
                });
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        executor.shutdown();
    }
}

/**
输出结果:
// 这是不出现异常的情况
结果666(null表示之前出现异常导致结果无法传过来)
结果为666(-1表示之前出现异常，经过handler使得结果处理成-1)

// 这是出现异常的情况
结果null(null表示之前出现异常导致结果无法传过来)
结果为-1(-1表示之前出现异常，经过handler使得结果处理成-1)
**/

可以看到通过handle类似于Java异常处理的finally，出现异常并不会像使用exceptionally那样中断后续的任务，而是继续执行，可以通过handle为之前出现异常无法获得的结果重新赋值（根据业务需求设置安全值之类的）。

⑥ 两组任务按顺序执行

thenCompose 实现两组任务按前后顺序执行 
public  CompletableFuture thenCompose(
    Function> fn)
复制代码

A.thenCompose(B)相当于任务A要排在任务B前面，即顺序的执行任务A、任务B。该方法的参数是函数式接口，函数式接口的参数是调用者的执行结果，返回值是另一个任务B。

public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(4);
    try {
        CompletableFuture actionA = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务A先执行结果为666");
            return 666;
        }, executor);

        actionA.thenCompose((res) ->  CompletableFuture.supplyAsync(() -> {
            System.out.println("任务B后执行结果加上333");
            return 333 + res;
        })).whenComplete((res, ex) -> System.out.println(res));
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        executor.shutdown();
    }
}

/**
输出结果:
    任务A先执行结果为666
    任务B后执行结果加上333
    999
**/

⑦ 两组任务谁快用谁

applyToEither 比较两组任务执行速度，谁快消费谁的执行结果 
public  CompletableFuture applyToEither(
        CompletionStage other, Function fn)

该方法用于比较两组任务的执行速度，谁先执行完就用谁的执行结果。

传入参数说明：第一个参数传入的是另一个任务的执行内容，第二个参数传入的是最终这两个任务谁快返回谁的结果，并通过当前函数式接口进行接收和处理（使用函数式接口，有参且有返回值）。

// 例子
public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(4);
    try {
        CompletableFuture actionA = CompletableFuture.supplyAsync(() -> {
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("任务A等待久一点，执行结果为555");
            return 555;
        }, executor);

        actionA.applyToEither(CompletableFuture.supplyAsync(() -> {
            System.out.println("任务B很快，执行结果为666");
            return 666;
        }), (res) -> {
            System.out.println("最终使用的执行结果为" + res);
            return res;
        });
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        executor.shutdown();
    }
}
/**
输出结果:
    任务B很快，执行结果为666
    最终使用的执行结果为666
    任务A等待久一点，执行结果为555
**/
除了applyToEither对任务最终结果进行获取并消费，并且具有返回值的方法外，还有两个类似的方法。 
// 这个方法效果和上面的一样，比谁快拿谁的结果，不同的是这个方法只消费不具有返回值
public CompletableFuture acceptEither(
        CompletionStage other, Consumer action)
// 这个方法效果和上面的一样，比谁快拿谁的结果，不同的是这个方法不消费结果也不具有返回值
public CompletableFuture runAfterEither(
        CompletionStage other, Runnable action)

⑧ 两组任务完成后合并

thenCombine 等待两组任务执行完毕后，合并两组任务的执行结果 
 public  CompletableFuture thenCombine(
        CompletionStage other,
        BiFunction fn)

该方法用于两组任务都完成后，将两组任务的执行结果一起交给当前方法的BiFunction处理。先完成的任务会等待后者任务完成。

传入参数说明：第一个参数传入的是另一个任务的执行内容，第二个参数传入的是带两个参数的函数式接口（第一个参数是任务1的执行结果，第二个参数是任务2的执行结果，具有返回值）。

// 例子
public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(4);
    try {
        CompletableFuture actionA = CompletableFuture.supplyAsync(() -> {
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("任务A等待久一点，执行结果为333");
            return 333;
        }, executor);

        CompletableFuture actionB = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务B很快，执行结果为666");
            return 666;
        }, executor);

        actionA.thenCombine(actionB, (res1, res2) -> {
            System.out.println("最终使用的执行结果为" + (res1 + res2));
            return res1 + res2;
        });
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        executor.shutdown();
    }
}

/**
输出结果:
    任务B很快，执行结果为666
    任务A等待久一点，执行结果为333
    最终使用的执行结果为999
**/
除了thenCombine对任务最终结果进行获取并消费，并且具有返回值的方法外，还有两个类似的方法。 
// 这个方法效果和上面的一样，获取合并结果，不同的是这个方法只消费不具有返回值
public  CompletableFuture thenAcceptBoth(
    CompletionStage other,
    BiConsumer action)
// 这个方法效果和上面的一样，获取合并结果，不同的是这个方法不消费结果也不具有返回值
public CompletableFuture runAfterBoth(CompletionStage other,
                                                Runnable action)

⑨ 多任务组合

  1. allOf 实现并行地执行多个任务，等待所有任务执行完成（无需考虑执行顺序）
public static CompletableFuture allOf(CompletableFuture... cfs)

该方法可以实现并行地执行多个任务，适用于多个任务没有依赖关系，可以互相独立执行的，传入参数为多个任务，没有返回值。

allOf()方法会等待所有的任务执行完毕再返回，可以通过get()阻塞确保所有任务执行完毕

// 例子
public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(4);
    try {
        CompletableFuture actionA = CompletableFuture.runAsync(() -> {
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("任务A等待2秒后执行完毕");
        }, executor);

        CompletableFuture actionB = CompletableFuture.runAsync(() -> {
            System.out.println("任务B很快执行完毕");
        }, executor);

        CompletableFuture actionC = CompletableFuture.runAsync(() -> {
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("任务C等待1秒后执行完毕");
        }, executor);

        CompletableFuture actionD = CompletableFuture.runAsync(() -> {
            try { TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("任务D等待5秒后执行完毕");
        }, executor);

        CompletableFuture.allOf(actionA, actionB, actionC, actionD).get();
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        executor.shutdown();
    }
}

/**
输出结果:
    任务B很快执行完毕
    任务C等待1秒后执行完毕
    任务A等待2秒后执行完毕
    任务D等待5秒后执行完毕
**/
  1. anyOf 实现并行地执行多个任务，只要有个一个完成的便会返回执行结果
public static CompletableFuture anyOf(CompletableFuture... cfs) 
 
该方法可以实现并行地执行多个任务，传入参数为多个任务，具有返回值。该方法不会等待所有任务执行完成后再返回结果，而是当有一个任务完成时，便会返回那个任务的执行结果。
 
 
// 例子
public static void main(String[] args) {
    // 快速创建线程池
    ExecutorService executor = Executors.newFixedThreadPool(4);
    try {
        CompletableFuture actionA = CompletableFuture.supplyAsync(() -> {
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("任务A等待2秒后执行完毕");
            return 555;
        }, executor);

        CompletableFuture actionB = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务B很快执行完毕");
            return 666;
        }, executor);

        CompletableFuture actionC = CompletableFuture.supplyAsync(() -> {
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("任务C等待1秒后执行完毕");
            return 999;
        }, executor);

        CompletableFuture actionD = CompletableFuture.supplyAsync(() -> {
            try { TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("任务D等待5秒后执行完毕");
            return 888;
        }, executor);

        System.out.println("最先执行完的返回结果为" + CompletableFuture.anyOf(actionA, actionB, actionC, actionD).get());
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        executor.shutdown();
    }
}

/**
输出结果:
    任务B很快执行完毕
    最先执行完的返回结果为666
    任务C等待1秒后执行完毕
    任务A等待2秒后执行完毕
    任务D等待5秒后执行完毕
**/
 
 
 
 
一个使用CompletableFuture异步编排的例子
 
 
不需要关心例子中的业务内容，使用时按照自己业务的需求，对不同的需求调用不同API即可。
 
 
编写任务时主要关心以下几点： ① 是否需要消费之前任务的结果 ② 是否需要返回结果给其他任务消费 ③ 是否要求顺序执行（是否允许并行，有没有前置要求）
 
 
/**
 * 该方法用于获取单个商品的所有信息
 * 1\. 商品的基本信息
 * 2\. 商品的图片信息
 * 3\. 商品的销售属性组合
 * 4\. 商品的各种分类基本信息
 * 5\. 商品的促销信息
 */
@Override
public SkuItemVo item(Long skuId) throws ExecutionException, InterruptedException {
    // 创建商品Vo通过各个任务去完善Vo的信息
    SkuItemVo skuItemVo = new SkuItemVo();

    // 获取商品基本信息 查询到后设置进Vo中，返回基本信息给后续任务消费 （使用自定义的线程池进行异步）
    CompletableFuture infoFuture = CompletableFuture.supplyAsync(() -> {
        SkuInfoEntity info = this.getById(skuId);
        skuItemVo.setInfo(info);
        return info;
    }, executor);

    // 获取商品的图片信息 获取后设置进Vo中，此处不需要消费图片信息，也不需要返回结果。所以使用runAsync即可
    CompletableFuture imageFuture = CompletableFuture.runAsync(() -> {
        List imagesEntities = skuImagesService.getImagesBySkuId(skuId);
        skuItemVo.setImages(imagesEntities);
    }, executor);

    // 获取商品销售属性 因为要利用之前查询到的基本信息，但后续任务不需要消费销售属性（不需要返回结果），所以使用thenAcceptAsync消费之前的基本信息，不返回销售信息。
    CompletableFuture saleAttrFuture = infoFuture.thenAcceptAsync((res) -> {
        List saleAttrVos = skuSaleAttrValueService.getSaleAttrBySpuId(res.getSpuId());
        skuItemVo.setSaleAttr(saleAttrVos);
    }, executor);

    // 获取商品各分类基本信息，同样要消费之前的基本信息，但无需返回，所以使用thenAcceptAsync即可
    CompletableFuture descFuture = infoFuture.thenAcceptAsync((res) -> {
        SpuInfoDescEntity spuInfoDescEntity = spuInfoDescService.getById(res.getSpuId());
        skuItemVo.setDesc(spuInfoDescEntity);
    }, executor);

    // 获取商品的促销信息 这个也不需要消费之前任务的结果，也不需要返回结果。所以直接使用runAsync即可
    CompletableFuture seckillFuture = CompletableFuture.runAsync(() -> {
        R skuSeckilInfo = seckillFeignService.getSkuSeckilInfo(skuId);
        if (skuSeckilInfo.getCode() == 0) {
            SeckillSkuVo seckilInfoData = skuSeckilInfo.getData("data", new TypeReference() {
            });
            skuItemVo.setSeckillSkuVo(seckilInfoData);

            if (seckilInfoData != null) {
                long currentTime = System.currentTimeMillis();
                if (currentTime > seckilInfoData.getEndTime()) {
                    skuItemVo.setSeckillSkuVo(null);
                }
            }
        }
    }, executor);

    // 使用allOf()组合所有任务，并且使用get()阻塞，等待所有任务完成。
        // 补充：infoFuture不能放入allOf中，因为allOf是并行无序执行（需要多个条件是无依赖性的）的，当上面任务中有需要消费infoFuture的结果，所以需要先执行infoFuture。
    CompletableFuture.allOf(imageFuture，saleAttrFuture,descFuture,seckillFuture).get();

    // 最后返回商品Vo
    return skuItemVo;
}
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java后端程序员)

        

            

                
    
                    
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）
                        编程经验分享
开发工具服务器sshlinux
                        
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 利用LangChain的StackExchange组件实现智能问答系统
                        nseejrukjhad
langchainmicrosoft数据库python
                        
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
    
                    
    • 
                    
  • 人工智能时代，程序员如何保持核心竞争力？
                        jmoych
人工智能
                        
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
    
                    
    • 
                    
  • 如何自学软件编程？零基础自学编程入门指南
                        _pangzi

                        
    前言零基础自学编程的动力是什么?在开启学习编程之路的时候必须搞清楚自己为什么要学编程?是因为工资高?还是对编程有浓厚的兴趣？还有自己有一定的编程基础想要继续提升自己？其实对于这个问题需要具体分析，如果是单纯看到程序员工资高，而自己本身并没有什么兴趣，那我不建议自学，可以选择参加培训或者不要进入编程领域不然自己学不会没有获得高薪，反而浪费了大把的时间，如果方法不对，反而会打击自信心。下面小编针对学习
    
                    
    • 
                    
  • ChatGPT 高效学习套路揭秘：让知识获取事半功倍的秘诀
                        kkai人工智能
chatgpt人工智能学习媒体ai
                        
    最近这段时间，AI热潮因ChatGPT的火爆再次掀起。如今，网上大部分内容都在调侃AI，但很少有人探讨如何正经使用ChatGPT做事情。作为一名靠搜索引擎和GitHub自学编程的开发者，第一次和ChatGPT深度交流后，我就确信：ChatGPT能够极大提高程序员学习新技术的效率。使用ChatGPT一个月后，我越发感受到它的颠覆性。因此，我想从工作和学习的角度，分享它的优势及我的一些使用技巧，而非娱
    
                    
    • 
                    
  • 程序员如何在AI时代保持核心竞争力
                        nfgo
chatgpt人工智能
                        
    程序员如何在AI时代保持核心竞争力随着AIGC（如ChatGPT、MidJourney、Claude等）大语言模型的相继涌现，AI辅助编程工具逐渐普及，程序员的工作方式正在发生深刻的变革。AI不仅能够自动生成代码，还能优化、调试、甚至提出解决方案。这一趋势让许多人担心：AI会不会最终取代部分编程工作？然而，也有人认为AI是提升效率的得力助手。那么，程序员在这个AI崛起的时代该如何应对？是专注某个领
    
                    
    • 
                    
  • 程序员架构师主要是做什么_程序员架构师：职责、技能与挑战
                        绿色小猪

                        
    免费备考资料（2024年11月软考）：历年试题+视频课合集+电子讲义点击领取>>>免费刷题：2024年11月软考备考刷题点此进入>>>程序员架构师的角色定位在软件开发领域，程序员架构师是一个至关重要的角色。他们不仅需要深入理解业务需求，还要将其转化为技术上的解决方案。程序员架构师是项目中的技术领航者，负责制定和维护软件系统的整体架构，确保系统的可扩展性、可维护性和性能。他们的工作涉及从概念化到实现
    
                    
    • 
                    
  • 2020年最新程序员职业发展路线指南，超详细！
                        编程流川枫
11编程语言程序员互联网IT职业
                        
    【文章来源微信公众号：每天学编程】01、程序员的特性技术出身的职场人特性很明显，与做市场、业务出身的职场人区别尤其明显。IT行业中常见的一些职场角色：老板、项目经理、产品经理、需求分析师、设计师、开发工程师、运维工程师等。开发工程师具有如下特征：1、逻辑思维清晰、严谨和细腻；但是有时不容易转弯，有些程序员容易较劲、钻牛角尖。2、性格偏内向、不善于沟通、表达和交际；但是在网络聊天工具上，有些显为幽默
    
                    
    • 
                    
  • 40岁的java程序员，还有出路吗？
                        cesske
java开发语言
                        
    目录前言一、现状与挑战二、出路与机遇三、案例分析与启示四、结语前言40岁Java程序员的出路：挑战与机遇并存在科技日新月异的今天，IT行业始终保持着高速的发展态势，而Java作为其中的重要一员，其地位依然稳固且充满挑战。对于一位40岁的Java程序员而言，面对职业生涯的“中年危机”，是否还有出路？本文将从多个维度探讨这一问题，旨在为这一群体提供思考和启示。一、现状与挑战职场竞争加剧随着技术的不断发
    
                    
    • 
                    
  • 程序员单身
                        单身总动员

                        
    如何判断一个男人会不会出轨?容易知足的男人，相对靠谱。他们不会想要通过征服很多异性来证明自己的魅力，他觉得有你一个就够了，多了他也没精力去讨好；他们也特别踏实，只会用行动来向你证明自己。专注于某项兴趣的男人，相对靠谱。比如小编的朋友，是个程序员，世人眼中的闷骚男，他专注于编程，每天24小时除了吃饭睡觉，脑子里想的都是代码，空间、微博也全是代码，最大的业余爱好就是打打游戏，他对老婆就特别专一。综上所
    
                    
    • 
                    
  • Python开发游戏？也太好用了吧
                        七步编程
工具Githubpythonpython游戏开发语言
                        
    程序员宝藏库：https://gitee.com/sharetech_lee/CS-Books-Store当然可以啦！现在日常能够用到和想到的场景，绝大多数都可以用Python实现。效果怎么样暂且不提，但是得益于丰富的第三方工具包，的确让Python能够很容易处理各种各样的场景。对于游戏开发也是这样，如果真的要想商业化，Python在游戏开发方面肯定没办法和C++相提并论，但是如果用于日常学习和自
    
                    
    • 
                    
  • 超级无敌详细的Mysql数据库笔记（基础篇版）
                        当大哥爱上学习
mysql数据库笔记
                        
    注：本篇笔记根据黑马程序员MySQL数据库入门到精通的内容所创建，适合复习和结合该视频学习使用。一.基础1.关系型数据库(RDBMS)概念:建立在关系模型基础上，由多张相互连接的二维表组成的数据库。特点:使用表存储数据，格式统一，便于维护使用SQL语言操作，标准统一，使用方便。2.SQLSQL通用语法SQL语句可以单行或多行书写，以分号结尾.SQL语句可以使用空格/缩进来增强语句的可读性。MySQ
    
                    
    • 
                    
  • 函数可以返回数组吗？有哪3种返回方法呢？如代码种的func2、func3、func4都可以返回数组。func1为什么会报错呢？关于返回数组需要注意哪些呢？
                        神笔馬良
java算法数据结构
                        
    问题描述：根据下列代码回答下列问题。//Createdby黑马程序员.#include"iostream"usingnamespacestd;/**函数返回数组，就是返回指针，要注意：*-不可返回局部数组（在函数内创建的数组），如果要返回需要*-static修饰*-动态内存创建（new[]、delete[]）*-返回全局（在函数外创建的对象）**不推荐函数返回数组，因为要么手动delete、要么s
    
                    
    • 
                    
  • 有个程序员的老公是种什么体验，嫁给程序员，我超级后悔！
                        前端小芳

                        
    1：在我还没长开的时候，就常听人说，有两种男人不能嫁：一种是兵哥哥，另一种是程序员。前者见不着，后者死的早。一想到不等头发花白，就要踟蹰独行，我就害怕的厉害。所以，很长一段时间，都对身边的程序员们避而远之。甚至做梦也没有想到，自己会成为程序员的老婆，而且一做就是好多年。2：那天全市停水，为了给部门同事解渴。我气喘吁吁地从超市搬来10瓶矿泉水。“注意性价比啊，一瓶500毫升的水3块，你30块买了5升
    
                    
    • 
                    
  • Github官方桌面客户端
                        zwb_jianshu

                        
    GitHub是一个面向开源及私有软件项目的托管平台，因为只支持git作为唯一的版本库格式进行托管，故名gitHub。如果你是一名程序员，那么一定会听过或用过现在最流行的版本控制工具GIT！而GitHub.com则是目前全球最热门的公共代码仓库网站，多到数不清的知名开源项目源代码都是托管在它上面。GitHubDesktop免费的Github官方桌面客户端首先，我先对GitHub来一个简单的介绍，Gi
    
                    
    • 
                    
  • 一文搞懂应用架构的3个核心概念
                        公众号-架构师汤师爷
后端架构设计JavaSaaS
                        
    如果你是一名业务开发，你可能要说，我整天就是做CRUD（增删改查），哪里需要了解什么应用架构设计？经常有人说，程序员35岁之后很容易陷入瓶颈，被行业淘汰，我觉得原因其实就在此。有些朋友在写代码的时候，可能没有太多考虑非功能性的需求、扩展性，只是完成功能，觉得能用就好。做事情的时候，也没有长远的规划，只是把眼前的事情做好就满足了。我面试过很多大龄候选人，他们的简历长达十几页，项目经历有几十个。然而，
    
                    
    • 
                    
  • Java中的服务端点响应缓存：Spring Cache抽象
                        微赚淘客机器人开发者联盟@聚娃科技
java缓存spring
                        
    Java中的服务端点响应缓存：SpringCache抽象大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在Java后端服务开发中，缓存是一个重要的性能优化手段。Spring框架提供了一个强大的缓存抽象，允许开发者以统一的方式使用不同的缓存技术。本文将介绍如何在Java应用中使用SpringCache抽象来实现服务端点的响应缓存。响应缓存的重要性响应缓存在服务端点中
    
                    
    • 
                    
  • oracle数据库安装和配置详细讲解
                        程序员小羊！
运维数据库oracle
                        
    大家好，我是程序员小羊！前言：Oracle数据库是全球广泛使用的关系型数据库管理系统(RDBMS)，提供高性能、可靠性、安全性和可扩展性，广泛应用于企业关键任务系统。下面详细介绍如何在CentOS系统上安装和配置Oracle数据库。1.前提条件1.1硬件要求内存：最小1GB，推荐2GB以上。硬盘：至少10GB的可用空间，视具体应用需求而定。1.2软件要求操作系统：CentOS7或CentOS8（确
    
                    
    • 
                    
  • 切换淘宝最新镜像源npm详细讲解
                        程序员小羊！
杂文npm前端node.js
                        
    大家好，我是程序员小羊！前言：在中国大陆，npm（NodePackageManager）的默认源由于网络限制，速度可能较慢。为了解决这个问题，淘宝提供了一个镜像源，它同步了npm的官方仓库，并显著提升了访问速度。切换到淘宝的镜像源可以加快npm包的下载速度。下面是详细的切换步骤及相关说明。1.查看当前npm源在更改npm源之前，查看当前npm使用的源地址：npmconfiggetregistry默
    
                    
    • 
                    
  • 一文理解 Python 中的环境变量
                        简讯Alfred
和我一起零基础学Python简明python教程零基础学pythonpython环境变量
                        
    你好，我是简讯！一枚野生程序员。热爱编程，但目前的工作与编程毫无关系。正在尝试各种副业，目前有做：红包封面商城：如何利用红包封面打造副业购物平台赚取佣金：利用淘宝京东等平台优惠券赚取佣金编辑器使用Neovim多一点，如果你也喜欢使用Nvim，我们可以一起交流。我的Nvim配置：https://github.com/alpha87/nvim。个人公众号经常会分享一些编程相关的文章，还有一些我已经操作
    
                    
    • 
                    
  • Java中的垃圾回收机制是如何工作的？
                        Good_tea_h
javajvm算法
                        
    Java中的垃圾回收机制（GarbageCollection,GC）是Java虚拟机（JVM）的一个重要组成部分，它负责自动管理内存的分配和释放，以减轻程序员在内存管理方面的负担，并防止内存泄漏和内存溢出等问题。一、垃圾回收机制的核心思想Java的垃圾回收机制主要基于两个核心思想：标记和回收。标记：垃圾收集器会定期自动扫描内存中的对象，根据特定的算法（如可达性分析法）来判断哪些对象已经不再被程序使
    
                    
    • 
                    
  • Android app后台运行休眠仍然可以运行的方法（确保一直运行)
                        2401_84102689
2024年程序员学习android
                        
    先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《2024年最新Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
    
                    
    • 
                    
  • 我们都是小小发明家
                        蜻蜓之旅

                        
    说到健康码，相信大家都再熟悉不过了。让人惊奇的是，发明它的并不是程序员而是杭州民警钟毅带着他的团队研发出来的。以前只要听到发明家，就觉得特别高大上，好像离我们普通人比较遥远。以前我也这么认为，直到看到了这本《超能编程队4：我是发明家》，才明白原来发明家就在我们身边，就像那位民警一样，他并不是那么遥不可及的。他可以是我们生活中的每一个人，只要你肯创造、肯想象、肯实践，愿意为大家服务、愿意为社会创造价
    
                    
    • 
                    
  • 月度总结 | 2022年03月 | 考研与就业的抉择 | 确定未来走大数据开发路线
                        「已注销」
个人总结hadoop
                        
    一、时间线梳理3月3日，寻找到同专业的就业伙伴3月5日，着手准备Java八股文，决定先走Java后端路线3月8月，申请到了校图书馆的考研专座，决定暂时放弃就业，先准备考研，买了数学和408的资料书3月9日-3月13日，因疫情原因，宿舍区暂封，这段时间在准备考研，发现内容特别多3月13日-3月19日，大部分时间在刷Hadoop、Zookeeper、Kafka的视频，同时在准备实习的项目3月20日，退
    
                    
    • 
                    
  • 程序员35岁会失业吗？
                        Good kid.
经验分享笔记
                        
    35岁被认为是程序员职业生涯的分水岭，许多程序员开始担忧自己的职业发展是否会受到年龄的限制。有人担心随着年龄的增长，技术更新换代的速度会使得资深程序员难以跟上；而另一些人则认为，丰富的经验和深厚的技术积累是年轻程序员无法比拟的宝贵财富。那么，让我们来探讨一下这个话题。技术更新与个人适应性确实，技术的快速发展对程序员的职业技能有一定的影响。新的编程语言、框架和工具不断涌现，程序员需要不断学习和适应这
    
                    
    • 
                    
  • 关于Echarts的一些设置总结
                        夏之小星星
echarts前端javascript
                        
    最近领导让我一个偏后端程序员画各种数据展示echarts页面，遇到好多问题在此记录一下，未完待续。。。ps：不喜欢画页面啊啊啊啊啊，以前公司这些都是ui的活啊啊啊啊，折磨死我啦啊啊啊啊一、柱形图1、echarts如何设置柱形颜色渐变在option加color属性option={color:{type:'linear',//x=0,y=1,柱子的颜色在垂直方向渐变x:0,y:1,colorStops
    
                    
    • 
                    
  • Python教程：面向对象
                        无敌开心
python开发语言
                        
    模块3：Python高级模块概述本课程旨在介绍Python编程语言中的面向对象编程（OOP）概念和技术。学生将学习如何使用类、对象、继承、多态等OOP的关键要素来构建灵活、可重用和可扩展的代码。通过实际编程练习和项目，学生将提高他们的编程技能，学会设计和实现面向对象的解决方案。面向对象编程是在面向过程编程的基础上发展来的，它比面向过程编程具有更强的灵活性和扩展性。面向对象编程是程序员发展的分水岭，
    
                    
    • 
                    
  • 如果面试官问你CAS，你还这么答，可能就要回去等通知了
                        爱玛士
程序员面试Javajava面试开发语言程序员架构
                        
    前言大家好，我是JAVA高级开发之路，一个总在为粉丝解决面试题的程序员。最近有几个粉丝说在面试面试中遇到了CAS的问题，连着几次面试都没有让面试官满意，区区CAS底层源码，怎能难倒咱们这届程序员们呢？都支棱起来，跟我一起来搞定CAS底层源码。什么是CASCAS的全称是Compare-And-Swap，它是CPU并发原语。它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原
    
                    
    • 
                    
  • 程序员被公司开除，隔阵子领导命令回公司讲解代码，网友纷纷支招
                        编程彭于晏

                        
    对于很多已经步入社会已经开始上班的人来说，离职是一件很常见的事情。有的是员工自己要求离职，可能是有更好的就业机会，也可能是有私事处理，不能继续工作；有的则是企业开除员工，或者是因为员工工作不努力，划水，或者是公司结构调整，需要裁员。但是不管是哪种原因吧，员工在离职前都需要和后来接任的同事将自己手上负责的工作进行交接，包括财务信息、已完成工作、未完成工作等，一方面是给曾经的公司和同事留下一个好印象，
    
                    
    • 
                                
  • Java 并发包之线程池和原子计数
                                    lijingyao8206
Java计数ThreadPool并发包java线程池
                                    
    对于大数据量关联的业务处理逻辑，比较直接的想法就是用JDK提供的并发包去解决多线程情况下的业务数据处理。线程池可以提供很好的管理线程的方式，并且可以提高线程利用率，并发包中的原子计数在多线程的情况下可以让我们避免去写一些同步代码。 
    这里就先把jdk并发包中的线程池处理器ThreadPoolExecutor 以原子计数类AomicInteger 和倒数计时锁C
    
                                
    • 
                                
  • java编程思想 抽象类和接口
                                    百合不是茶
java抽象类接口
                                    
    接口c++对接口和内部类只有简介的支持,但在java中有队这些类的直接支持 
  
1 ,抽象类 :  如果一个类包含一个或多个抽象方法,该类必须限定为抽象类(否者编译器报错) 
  
抽象方法 : 在方法中仅有声明而没有方法体  
  
 
package com.wj.Interface;


    
                                
    • 
                                
  • [房地产与大数据]房地产数据挖掘系统
                                    comsci
数据挖掘
                                    
     
       随着一个关键核心技术的突破,我们已经是独立自主的开发某些先进模块,但是要完全实现,还需要一定的时间... 
 
       所以,除了代码工作以外,我们还需要关心一下非技术领域的事件..比如说房地产 
 
    &nb
    
                                
    • 
                                
  • 数组队列总结
                                    沐刃青蛟
数组队列
                                    
      
    数组队列是一种大小可以改变，类型没有定死的类似数组的工具。不过与数组相比，它更具有灵活性。因为它不但不用担心越界问题，而且因为泛型（类似c++中模板的东西）的存在而支持各种类型。 
  
   以下是数组队列的功能实现代码： 
  
import List.Student;

public class
    
                                
    • 
                                
  • Oracle存储过程无法编译的解决方法
                                    IT独行者
oracle存储过程　
                                    
    今天同事修改Oracle存储过程又导致2个过程无法被编译，流程规范上的东西，Dave 这里不多说，看看怎么解决问题。 
   


1.     查看无效对象  
XEZF@xezf(qs-xezf-db1)> select object_name,object_type,status from all_objects where status='IN
    
                                
    • 
                                
  • 重装系统之后oracle恢复
                                    文强chu
oracle
                                    
    前几天正在使用电脑，没有暂停oracle的各种服务。 
突然win8.1系统奔溃，无法修复，开机时系统 提示正在搜集错误信息，然后再开机，再提示的无限循环中。 
无耐我拿出系统u盘 准备重装系统，没想到竟然无法从u盘引导成功。 
晚上到外面早了一家修电脑店，让人家给装了个系统，并且那哥们在我没反应过来的时候， 
直接把我的c盘给格式化了 并且清理了注册表，再装系统。 
然后的结果就是我的oracl
    
                                
    • 
                                
  • python学习二（ 一些基础语法）
                                    小桔子
pthon基础语法
                                    
    紧接着把！昨天没看继续看django 官方教程，学了下python的基本语法 与c类语言还是有些小差别： 
1.ptyhon的源文件以UTF-8编码格式 
2. 
 /   除 结果浮点型 
 //  除 结果整形 
 %   除 取余数 
 *   乘 
 **  乘方 eg 5**2 结果是5的2次方25 
 _&
    
                                
    • 
                                
  • svn 常用命令
                                    aichenglong
SVN版本回退
                                    
    1 svn回退版本 
  1)在window中选择log,根据想要回退的内容,选择revert this version或revert chanages from this version 
 两者的区别: 
  revert this version:表示回退到当前版本(该版本后的版本全部作废) 
  revert chanages from this versio
    
                                
    • 
                                
  • 某小公司面试归来
                                    alafqq
面试
                                    
    先填单子，还要写笔试题，我以时间为急，拒绝了它。。时间宝贵。 
老拿这些对付毕业生的东东来吓唬我。。 
 
面试官很刁难，问了几个问题，记录下； 
 
1，包的范围。。。public,private,protect. --悲剧了 
2，hashcode方法和equals方法的区别。谁覆盖谁.结果，他说我说反了。 
3，最恶心的一道题，抽象类继承抽象类吗？（察，一般它都是被继承的啊） 
4，stru
    
                                
    • 
                                
  • 动态数组的存储速度比较 集合框架
                                    百合不是茶
集合框架
                                    
    集合框架： 
自定义数据结构(增删改查等) 
package 数组;

/**
 * 创建动态数组
 * @author 百合
 *
 */

public class ArrayDemo{
	
	//定义一个数组来存放数据
	
	String[] src = new String[0];
	
	/**
	 * 增加元素加入容器 
	 * @param s要加入容器
    
                                
    • 
                                
  • 用JS实现一个JS对象，对象里有两个属性一个方法
                                    bijian1013
js对象
                                    
    <html> 
  <head> 
  </head> 
  <body> 
    用js代码实现一个js对象，对象里有两个属性，一个方法 
  </body> 
  <script> 
        var obj={a:'1234567',b:'bbbbbbbbbb',c:function(x){ 
 
    
                                
    • 
                                
  • 探索JUnit4扩展：使用Rule
                                    bijian1013
java单元测试JUnitRule
                                    
            在上一篇文章中，讨论了使用Runner扩展JUnit4的方式，即直接修改Test Runner的实现(BlockJUnit4ClassRunner)。但这种方法显然不便于灵活地添加或删除扩展功能。下面将使用JUnit4.7才开始引入的扩展方式——Rule来实现相同的扩展功能。 
1. Rule 
      &n
    
                                
    • 
                                
  • [Gson一]非泛型POJO对象的反序列化
                                    bit1129
POJO
                                    
    当要将JSON数据串反序列化自身为非泛型的POJO时，使用Gson.fromJson(String, Class)方法。自身为非泛型的POJO的包括两种： 
1. POJO对象不包含任何泛型的字段 
2. POJO对象包含泛型字段，例如泛型集合或者泛型类 
 Data类 a.不是泛型类， b.Data中的集合List和Map都是泛型的 c.Data中不包含其它的POJO   
 
    
                                
    • 
                                
  • 【Kakfa五】Kafka Producer和Consumer基本使用
                                    bit1129
kafka
                                    
    0.Kafka服务器的配置 
一个Broker， 
一个Topic 
Topic中只有一个Partition（）   1. Producer： 
package kafka.examples.producers;


import kafka.producer.KeyedMessage;
import kafka.javaapi.producer.Producer;
impor
    
                                
    • 
                                
  • lsyncd实时同步搭建指南——取代rsync+inotify
                                    ronin47

                                    
    1. 几大实时同步工具比较 1.1 inotify + rsync 
最近一直在寻求生产服务服务器上的同步替代方案，原先使用的是 inotify + rsync，但随着文件数量的增大到100W+，目录下的文件列表就达20M，在网络状况不佳或者限速的情况下，变更的文件可能10来个才几M，却因此要发送的文件列表就达20M，严重减低的带宽的使用效率以及同步效率；更为要紧的是，加入inotify
    
                                
    • 
                                
  • java-9. 判断整数序列是不是二元查找树的后序遍历结果
                                    bylijinnan
java
                                    
    

public class IsBinTreePostTraverse{
	
	static boolean isBSTPostOrder(int[] a){
		if(a==null){
			return false;
		}
		/*1.只有一个结点时，肯定是查找树
		 *2.只有两个结点时，肯定是查找树。例如{5,6}对应的BST是   6		{6,5}对应的BST是
    
                                
    • 
                                
  • MySQL的sum函数返回的类型
                                    bylijinnan
javaspringsqlmysqljdbc
                                    
    今天项目切换数据库时，出错 
 
访问数据库的代码大概是这样： 
 

String sql =  "select sum(number) as sumNumberOfOneDay from tableName";
List<Map> rows = getJdbcTemplate().queryForList(sql);
for (Map row : rows
    
                                
    • 
                                
  • java设计模式之单例模式
                                    chicony
java设计模式
                                    
      
在阎宏博士的《JAVA与模式》一书中开头是这样描述单例模式的： 
　　作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。  单例模式的结构
  
　　单例模式的特点： 
 
 单例类只能有一个实例。 
 单例类必须自己创建自己的唯一实例。 
 单例类必须给所有其他对象提供这一实例。 
 　　饿汉式单例类 
  
publ
    
                                
    • 
                                
  • javascript取当月最后一天
                                    ctrain
JavaScript
                                    
    
<!--javascript取当月最后一天-->
<script   language=javascript>  
  var current = new Date();
  var year = current.getYear();
  var month = current.getMonth();
  showMonthLastDay(year, mont
    
                                
    • 
                                
  • linux tune2fs命令详解
                                    daizj
linuxtune2fs查看系统文件块信息
                                    
    一.简介： 
tune2fs是调整和查看ext2/ext3文件系统的文件系统参数，Windows下面如果出现意外断电死机情况，下次开机一般都会出现系统自检。Linux系统下面也有文件系统自检，而且是可以通过tune2fs命令，自行定义自检周期及方式。 
二.用法： 
Usage: tune2fs [-c max_mounts_count] [-e errors_behavior] [-g grou
    
                                
    • 
                                
  • 做有中国特色的程序员
                                    dcj3sjt126com
程序员
                                    
      
从出版业说起  网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。   许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有
    
                                
    • 
                                
  • Android：TextView属性大全
                                    dcj3sjt126com
textview
                                    
    android:autoLink    设置是否当文本为URL链接/email/电话号码/map时，文本显示为可点击的链接。可选值(none/web/email/phone/map/all)  android:autoText    如果设置，将自动执行输入值的拼写纠正。此处无效果，在显示输入法并输
    
                                
    • 
                                
  • tomcat虚拟目录安装及其配置
                                    eksliang
tomcat配置说明tomca部署web应用tomcat虚拟目录安装
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2097184 
1.-------------------------------------------tomcat  目录结构 
 
 config：存放tomcat的配置文件 
 temp  ：存放tomcat跑起来后存放临时文件用的 
 work   ： 当第一次访问应用中的jsp
    
                                
    • 
                                
  • 浅谈：APP有哪些常被黑客利用的安全漏洞
                                    gg163
APP
                                    
    首先，说到APP的安全漏洞，身为程序猿的大家应该不陌生；如果抛开安卓自身开源的问题的话，其主要产生的原因就是开发过程中疏忽或者代码不严谨引起的。但这些责任也不能怪在程序猿头上，有时会因为BOSS时间催得紧等很多可观原因。由国内移动应用安全检测团队爱内测（ineice.com）的CTO给我们浅谈关于Android 系统的开源设计以及生态环境。 
1. 应用反编译漏洞：APK 包非常容易被反编译成可读
    
                                
    • 
                                
  • C#根据网址生成静态页面
                                    hvt
Web.netC#asp.nethovertree
                                    
    HoverTree开源项目中HoverTreeWeb.HVTPanel的Index.aspx文件是后台管理的首页。包含生成留言板首页，以及显示用户名，退出等功能。根据网址生成页面的方法： 
  
bool CreateHtmlFile(string url, string path)
{ 
//http://keleyi.com/a/bjae/3d10wfax.htm

stri
    
                                
    • 
                                
  • SVG 教程 （一）
                                    天梯梦
svg
                                    
    SVG 简介   
SVG 是使用 XML 来描述二维图形和绘图程序的语言。  学习之前应具备的基础知识： 
继续学习之前，你应该对以下内容有基本的了解： 
 
 HTML 
 XML 基础 
 
如果希望首先学习这些内容，请在本站的首页选择相应的教程。  什么是SVG？ 
 
 SVG 指可伸缩矢量图形 (Scalable Vector Graphics) 
 SVG 用来定义用于网络的基于矢量
    
                                
    • 
                                
  • 一个简单的java栈
                                    luyulong
java数据结构栈
                                    
    
public class MyStack {
	private long[] arr;

	private int top;

	public MyStack() {
		arr = new long[10];
		top = -1;
	}

	public MyStack(int maxsize) {
		arr = new long[maxsize];
		top 
    
                                
    • 
                                
  • 基础数据结构和算法八：Binary search
                                    sunwinner
AlgorithmBinary search
                                    
    Binary search needs an ordered array so that it can use array indexing to dramatically reduce the number of compares required for each search, using the classic and venerable binary search algori
    
                                
    • 
                                
  • 12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！
                                    刘星宇
c面试
                                    
    12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 
1.gets()函数 
问：请找出下面代码里的问题： 
#include<stdio.h> 
int main(void) 
{ 
    char buff[10]; 
    memset(buff,0,sizeof(buff)); 
 

    
                                
    • 
                                
  • ITeye 7月技术图书有奖试读获奖名单公布
                                    ITeye管理员
活动ITeye试读
                                    
    ITeye携手人民邮电出版社图灵教育共同举办的7月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 
 
 
7月试读活动回顾： 
http://webmaster.iteye.com/blog/2092746 
 
 
本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 
 
 
《Java性能优化权威指南》 
 
 
    
                                
    •