王劭阳
王劭阳

JUC并发编程与源码分析笔记03-CompletableFuture

Future接口理论知识复习

Future接口（FutureTask实现类）定义了操作异步任务执行的一些方法，如获取异步任务的执行结果、取消任务的执行、判断任务是否被取消、判断任务执行是否完毕等。
找到java.util.concurrent.Future，看到里面定义的方法，这些方法就是我们需要关注的方法。
Future接口可以为主线程开一个分支任务，专门为主线程处理耗时和费力的复杂业务。

Future接口常用实现类FutureTask异步任务

Future接口能干什么

Future是Java5新加的一个接口，它提供了一个异步并行计算的功能，如果主线程需要执行一个很耗时的计算任务，我们就可以通过Future把这个任务放到异步线程中执行，主线程继续处理其他任务或者先行结束，再通过Future获取计算结果。
目的：异步多线程任务执行且返回有结果，三个特点：多线程、有返回、异步任务。

本源的Future接口相关架构

JUC并发编程与源码分析笔记03-CompletableFuture_第1张图片
可以看到FutureTask实现了Runnable、Future接口，而且它的构造参数还支持传入Callable，所以FutureTask现在就具有多线程（Runnable）、有返回（Callable）、异步任务（Future）这3个特点了。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CompletableFutureDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(new MyThread());// 将一个耗时的操作封装到FutureTask里
        new Thread(futureTask, "threadName").start();// 启动一个子线程执行FutureTask
        System.out.println(futureTask.get());// 获取FutureTask的返回值
    }
}

class MyThread implements Callable<String> {
    @Override
    public String call() {
        System.out.println("MyThread.call");
        return "Hello Callable";
    }
}

Future编码实战和优缺点分析

优点

Future结合线程池，可以显著提高程序的执行效率。

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureThreadPoolDemo {
    /**
     * 有3个任务，分别耗时500ms，300ms，300ms
     * fun1()：3个任务由主线程依次执行
     * fun2()：将3个任务放到线程池执行
     */
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        fun1();
        fun2();
    }

    private static void fun2() throws InterruptedException, ExecutionException {
        long startTime = System.currentTimeMillis();
        ExecutorService executorService = Executors.newFixedThreadPool(3);// 创建一个线程池
        FutureTask<String> futureTask1 = new FutureTask<>(() -> {// 任务1
            Thread.sleep(500);
            return "task1 over";
        });
        executorService.submit(futureTask1);
        FutureTask<String> futureTask2 = new FutureTask<>(() -> {// 任务2
            Thread.sleep(300);
            return "task2 over";
        });
        executorService.submit(futureTask2);
        FutureTask<String> futureTask3 = new FutureTask<>(() -> {// 任务3
            Thread.sleep(300);
            return "task3 over";
        });
        executorService.submit(futureTask3);
        // 这里获取返回值，主线程会阻塞等待直到拿到返回值，如果把获取结果注释掉，fun2()的执行时间会很短，因为主线程执行完毕，但是子线程依旧在跑
        System.out.println(futureTask1.get());
        System.out.println(futureTask2.get());
        System.out.println(futureTask3.get());
        long endTime = System.currentTimeMillis();
        System.out.println("fun()2总耗时：" + (endTime - startTime));
        executorService.shutdown();// 关闭线程池
    }

    private static void fun1() throws InterruptedException {
        long startTime = System.currentTimeMillis();
        Thread.sleep(500);// 任务1
        Thread.sleep(300);// 任务2
        Thread.sleep(300);// 任务3
        long endTime = System.currentTimeMillis();
        System.out.println("fun1()总耗时：" + (endTime - startTime));
    }
}

缺点

get()阻塞

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class FutureAPIDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        FutureTask<String> futureTask = new FutureTask<>(()->{
            Thread.sleep(5000);
           return "task over";
        });
        new Thread(futureTask).start();
        System.out.println("主线程正在运行");
//        System.out.println(futureTask.get());// 阻塞，直到获取到返回结果
        System.out.println(futureTask.get(2000, TimeUnit.MILLISECONDS));// 只等待2000ms，超时未返回直接抛异常
    }
}

get()方法会有阻塞问题，导致主线程无法继续执行，另外提供了一个带参的get()方法，超时自动放弃等待。

isDone()轮询

有时候，在get()阻塞期间，我们希望看到进度或者提示信息，而不是一味地等待，可以将get()改成轮询，在轮询方法里通过isDone()判断任务是否执行完毕，只是多了一些提示信息。

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeoutException;

public class FutureAPIDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            Thread.sleep(5000);
            return "task over";
        });
        new Thread(futureTask).start();
        System.out.println("主线程正在运行");
//        System.out.println(futureTask.get());// 阻塞，直到获取到返回结果
//        System.out.println(futureTask.get(2000, TimeUnit.MILLISECONDS));// 只等待2000ms，超时未返回直接抛异常
        while (true) {
            if (futureTask.isDone()) {
                System.out.println(futureTask.get());
                break;
            } else {
                Thread.sleep(1000);
                System.out.println("正在处理中，请稍等……");
            }
        }
    }
}

这样的缺点就是：频繁的调用isDone()方法，对CPU来说是浪费资源。

结论

Future对于结果的获取不是很友好，只能通过阻塞或轮询的方式获取任务结果。

想完成一些复杂的任务

对于简单的业务场景，Future是完全可以胜任的。

回调通知

对于Future的完成时间，我们希望，完成之后可以通知主线程。

创建异步任务

Future结合线程池。

多个任务前后依赖可以组合处理(水煮鱼)

希望将多个异步任务的结果组合起来，后一个异步任务的计算需要前一个任务的值。
希望将多个异步计算合成成一个异步计算，这几个异步计算相互独立，同时，后一个的计算依赖前一个的计算结果。

对计算速度选最快

当Future集合中有多个任务的时候，处理最快的一个完成，返回第一个处理的结果。

CompletableFuture对Future的改进

CompletableFuture为什么会出现

Future中get()方法和isDone()方法都存在问题，对于真正的异步处理，我们希望可以通过回调函数，在Future结束之后，自动调用回调函数，这样就不用等待返回结果了。
阻塞的方式和异步编程的设计理念相违背，轮询会额外耗费CPU资源，因此JDK8设计出了CompletableFuture，它提供了一个类似观察者模式的机制，任务完成之后，通知监听的一方。

CompletableFuture和CompletionStage源码分别介绍

类架构说明

JUC并发编程与源码分析笔记03-CompletableFuture_第2张图片

接口CompletionStage

  • CompletionStage代表异步计算过程中的某个阶段，一个阶段完成后可能会触发另一个阶段，有些类似Linux系统管道分隔传参数
  • 一个阶段的执行可以是一个Function，Consumer或者Runnable。比如：stage.thenApply(x -> square(x)).thenAccept(x -> System.out.println(x)).thenRun(() -> System.out.println())
  • 一个阶段的执行可能被单个阶段的完成触发，有可能是由多个阶段一起触发

类CompletableFuture

  • 在Java8中，CompletableFuture提供了非常强大的Future扩展功能，可以帮助我们简化异步编程复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，提供了转换和组合CompletableFuture的方法
  • 它可能代表一个明确完成的Future，也可能带一个完成阶段（CompletionStage），它支持在计算完成后触发一些函数或者执行某些动作
  • 它实现了Future和CompletionStage接口

核心的四个静态方法，创建一个异步任务

runAsync：无返回值

public static CompletableFuture runAsync(Runnable runnable)
public static CompletableFuture runAsync(Runnable runnable, Executor executor)

supplyAsync：有返回值

public static CompletableFuture supplyAsync(Supplier supplier)
public static CompletableFuture supplyAsync(Supplier supplier, Executor executor)

上述Executor参数说明

没有指定线程池executor的时候，使用的是默认的ForkJoinPool.commonPool()，如果指定了线程池，则使用自定义的或指定的线程池。

Code

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureBuildDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        fun1();
        System.out.println("----------------------------------------");
        fun2();
        System.out.println("----------------------------------------");
        fun3();
        System.out.println("----------------------------------------");
        fun4();
    }

    private static void fun1() throws ExecutionException, InterruptedException {
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(completableFuture.get());
    }

    private static void fun2() throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, executorService);
        System.out.println(completableFuture.get());
        executorService.shutdown();
    }

    private static void fun3() throws ExecutionException, InterruptedException {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "CompletableFutureBuildDemo.fun3";
        });
        System.out.println(completableFuture.get());
    }

    private static void fun4() throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "CompletableFutureBuildDemo.fun4";
        }, executorService);
        System.out.println(completableFuture.get());
        executorService.shutdown();
    }
}

通用演示，减少阻塞和轮询

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadLocalRandom;

public class CompletableFutureUserDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        CompletableFuture.supplyAsync(() -> {
                    System.out.println(Thread.currentThread().getName());
                    int result = ThreadLocalRandom.current().nextInt();
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    return result;
                }, executorService)
                .whenComplete((v, e) -> {
                    if (e == null) {
                        System.out.println("计算完成，计算结果：" + v);
                    }
                })
                .exceptionally((e) -> {
                    e.printStackTrace();
                    System.out.println("出现异常：" + e.getCause() + "\t" + e.getMessage());
                    return null;
                });
        System.out.println(Thread.currentThread().getName() + "正在运行");
        executorService.shutdown();
    }
}

注意这里的一个坑，如果使用的是默认的线程池，主线程执行完毕后，CompletableFuture使用的默认线程池会立刻关闭，就会导致whenComplete方法不能被执行到，所以这里，还是推荐使用自定义线程池。
如果在supplyAsync方法中，出现了异常，也会走whenComplte方法，而且也走execptionally方法。

CompletableFuture的优点

  • 异步任务结束时，自动调用某个对象的方法
  • 主线程设置好回调后，不需要再关心异步任务的执行，异步任务之间可以顺序执行
  • 异步任务出错时，会自动回调某个对象的方法

案例精讲-从电商网站的比价需求说开去

函数式编程已经主流

Lambda表达式、Stream流式调用、Chain链式调用、Java8函数式编程。
函数式编程：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

@FunctionalInterface
public interface BiConsumer<T, U> {
    void accept(T t, U u);
}

@FunctionalInterface
public interface Supplier<T> {
    T get();
}
函数式接口名称 方法名称 参数个数 返回值
Runnable run 0 无
Function apply 1 有
Consumer accept 1 无
BiConsumer accept 2 无
Supplier get 0 有

还有一个常用的函数式接口，这里视频并没有提及，它是Predicate。

先说说join和get对比

CompletableFuture的get()方法和join()方法相比，作用是一样的，区别是get()在编译阶段，会抛出checkedException，而join()不会。
这里还学到一个Lombok的新知识：在类上添加这个注解：@Accessors(chain = true)// 开启链式写法，可以开启对象的链式写法，比如student.setId(1).setName("xxx").setMajor("yyy");，把原来竖着写的set方法，扭转成横着写了，算是个语法糖吧。

大厂业务需求说明

需求说明：
同一款产品，同时搜索出同款产品在各大电商平台的售价
同一款产品，同时搜索出本产品在同一电商平台下，各个入驻卖家售价
输出返回：
希望查询结果是这款产品在不同地方的价格清单列表，返回一个List
解决方案：
一步一步的查询，最后汇总，效率上会慢
多线程异步任务同时查询 ，返回结果汇总，效率上很高

一波流Java8函数式编程带走-比价案例实战Case

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;

public class CompletableFutureMallDemo {
    static List<Mall> mallList = new ArrayList() {{
        add(new Mall("jd", "mysql"));
        add(new Mall("tb", "mysql"));
        add(new Mall("dd", "mysql"));
    }};

    public static void main(String[] args) {
        long begin1 = System.currentTimeMillis();
        List<String> list1 = fun1(mallList, "mysql");
        list1.forEach(System.out::println);
        long end1 = System.currentTimeMillis();
        System.out.println("fun1用时：" + (end1 - begin1));
        System.out.println("---------------------------------------------");
        long begin2 = System.currentTimeMillis();
        List<String> list2 = fun2(mallList, "mysql");
        list2.forEach(System.out::println);
        long end2 = System.currentTimeMillis();
        System.out.println("fun2用时：" + (end2 - begin2));
    }

    private static List<String> fun1(List<Mall> mallList, String productName) {
        return mallList.stream().map(mall -> String.format("%s in %s price is %s", productName, mall.getMallName(), mall.calculatePrice())).collect(Collectors.toList());
    }

    private static List<String> fun2(List<Mall> mallList, String productName) {
        return mallList.stream().map(mall -> CompletableFuture.supplyAsync(() -> String.format("%s in %s price is %s", productName, mall.getMallName(), mall.calculatePrice())))
                .collect(Collectors.toList()).stream()// 这里collect一下，是为了让前一个stream流完成，这样stream流里的线程就可以开始运算，如果没有这一行，就起不到并行作用，因为stream有懒惰的特性，只有执行终端操作时候，才会真正执行运算
                .map(CompletableFuture::join).collect(Collectors.toList());
    }
}

@AllArgsConstructor
@NoArgsConstructor
@Data
@Accessors(chain = true)
class Mall {
    private String mallName;
    private String productName;

    public Double calculatePrice() {
        try {
            Thread.sleep(1000);// 模拟查询时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return ThreadLocalRandom.current().nextDouble();
    }
}

CompletableFuture常用方法

获取结果和触发计算

获取结果

public T get()
public T get(long timeout, TimeUnit unit)
public T join()
public T getNow(T valueIfAbsent)：如果在get的时候，还没有返回结果，就将valueIfAbsent的值作为返回值返回

主动触发计算

public boolean complete(T value)：方法首先判断进程有没有执行完，如果没有执行完，进行打断，并将value赋值为线程的返回值（通过get()或join()获取），如果执行完了，就不需要打断，线程的返回值就是线程里正常的返回值。
关于complete()方法的返回值，有点不好理解，如果线程是被complete()方法触发结束的，返回true，如果线程在执行complete()方法的时候，已经结束，返回false。

public static void main(String[] args) throws InterruptedException {
    CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "hello";
    });
    Thread.sleep(2000);
    System.out.println(completableFuture.complete("default") + "\t" + completableFuture.join());
}

修改主线程里的sleep为1000，子线程里的sleep为2000，查看结果对比。

对计算结果进行处理

计算结果存在依赖关系，这两个线程串行化。
public CompletableFuture thenApply(Function fn)
public CompletableFuture handle(BiFunction fn)

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureAPIDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("第一步");
            return 1;
        }, executorService).thenApply(v -> {
            System.out.println("第二步");
            int a = 1 / 0;
            return v + 1;
        }).thenApply(v -> {
            System.out.println("第三步");
            return v + 1;
        }).whenComplete((v, e) -> {
            if (e == null) {
                System.out.println("最终结果为：" + v);
            }
        }).exceptionally(e -> {
            e.printStackTrace();
            System.out.println(e.getMessage());
            return null;
        });
        executorService.shutdown();
        System.out.println(completableFuture.join());
    }
}

把thenApply换成handle，对比区别。可以看到，使用handle后第二步报错的情况下，第三步依旧执行了，而且会带着异常参数，可以根据异常参数做一些判断处理，使用thenApply的话，如果线程内部报错，后续的thenApply就不会执行了。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureAPIDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("第一步");
            return 1;
        }, executorService).handle((v, e) -> {
            System.out.println("第二步");
            int a = 1 / 0;
            return v + 1;
        }).handle((v, e) -> {
            System.out.println("第三步");
            return v + 1;
        }).whenComplete((v, e) -> {
            if (e == null) {
                System.out.println("最终结果为：" + v);
            }
        }).exceptionally(e -> {
            e.printStackTrace();
            System.out.println(e.getMessage());
            return null;
        });
        executorService.shutdown();
        System.out.println(completableFuture.join());
    }
}

对计算结果进行消费

public CompletableFuture thenAccept(Consumer action)
把线程的运算结果消费掉，没有返回值。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureAPIDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 1;
        }, executorService).thenAccept(System.out::println);
        executorService.shutdown();
    }
}

任务之间的执行顺序对比：
public CompletableFuture thenRun(Runnable action)：任务A执行完执行任务B，任务B不需要任务A的结果，也无返回值
public CompletableFuture thenAccept(Consumer action)：任务A执行完执行任务B，任务B需要任务A的结果，但是任务B无返回值
public CompletableFuture thenApply(Function fn)：任务A执行完执行任务B，任务B需要任务A的结果，但是任务B有返回值
CompletableFuture和线程池的说明：
如果不指定线程池，默认使用ForkJoinPool，如果指定了线程池，使用指定的线程池，在调用then*()方法的时候，还有一个then*Async()方法，如果使用了then*Async()方法，这个方法内的任务和这个方法后的任务都会使用ForkJoinPool来执行，除非你在then*Async()方法里又传了自定义线程池。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureAPIDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "";
        }, executorService).thenRun(() -> {
            System.out.println("任务2" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).thenRun(() -> {
            System.out.println("任务3" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executorService.shutdown();
    }
}

如果线程内执行的太快，Thread.currentThread().getName()的结果可能是main线程，比方说，把Thread.sleep()去掉，就可以复现。
查看thenRunAsync()方法，里面有一个asyncPool变量，查看它的赋值过程，判断useCommonPool，如果为真，使用ForkJoinPool，如果为假，新建一个线程池。useCommonPool的值又取决于ForkJoinPool.getCommonPoolParallelism() > 1，通过调试发现ForkJoinPool.getCommonPoolParallelism()的值是7，所以默认情况下，使用的是ForkJoinPool。

对计算速度进行选用

public CompletableFuture applyToEither(CompletionStage other, Function fn)
应用场景：一个方法需要实现多个查询服务，多个服务之间相互独立，只要有一个能返回结果，自动放弃等待其他未执行完的查询。
又找了一个例子：我计划从A到B去，有1路车和2路车，都可以到达，而且它们路线一致，我坐哪个呢？哪个车先来坐哪个呗，这里比较的是等待时间，可以把等待时间抽象成程序处理时间，哪个快走哪个，而且放弃其他所有的，也是这个道理。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureAPIDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "result1";
        }, executorService);
        CompletableFuture<String> completableFuture2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "result2";
        }, executorService);
        CompletableFuture<String> completableFuture = completableFuture1.applyToEither(completableFuture2, v -> v + " is winner");
        System.out.println(completableFuture.join());
        executorService.shutdown();
    }
}

对计算结果进行合并

public CompletableFuture thenCombine(CompletionStage other, BiFunction fn)
两个CompletionStage任务都完成后，将两个任务的结果一起提交给thenCombine来处理，先完成的任务需要等待另一个任务完成。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureAPIDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        CompletableFuture<Integer> completableFuture1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 10;
        }, executorService);
        CompletableFuture<Integer> completableFuture2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 20;
        }, executorService);
        CompletableFuture<Integer> completableFuture = completableFuture1.thenCombine(completableFuture2, (v1, v2) -> v1 * v2);
        System.out.println(completableFuture.join());
        executorService.shutdown();
    }
}

看到这里，发现弹幕有人提到public static CompletableFuture allOf(CompletableFuture... cfs)和public static CompletableFuture anyOf(CompletableFuture... cfs)老师没讲，我就自己搜索了下。
allOf接收若干个CompletableFuture，当所有的CompletableFuture都完成后，才会执行返回CompletableFuture。
anyOf接收若干个CompletableFuture，当任意一个任务执行完成，就返回CompletableFuture。

你可能感兴趣的:(JUC并发编程与源码分析,JUC)

  • 嵌入式SDIO 总线面试题及参考答案 大模型大数据攻城狮 fpga开发嵌入式面经SPIUSB接口SD总线SDIO总线牛客网
    目录SDIO总线与SD总线的核心区别是什么？(附框架图）简述SDIO总线物理接口的组成及其功能（CLK、CMD、DAT0-DAT3）。SDIO总线支持的最大数据传输位宽是多少？如何配置？解释SDIO总线中的主从模式架构及通信流程。SDIO卡的功能类型有哪些（如Wi-Fi、蓝牙、GPS）？SDIO总线时钟信号（CLK）的作用及典型频率范围SDIO协议中的OCR寄存器作用是什么？如何通过CMD5获取卡
  • 苹果签名的战略价值：解析六大核心优势与商业赋能逻辑 ios
    苹果签名的战略价值：解析六大核心优势与商业赋能逻辑（因篇幅过长所以分为两篇帖子发~）在iOS应用生态中，签名机制既是技术护城河，也是开发者突破分发限制的关键武器。本文将从开发效率、商业变现、安全管控等维度，深度剖析苹果签名体系带来的独特价值。一、突破AppStore审核壁垒，加速产品验证苹果签名最核心的优势在于规避冗长审核流程。根据2023年统计，AppStore平均审核周期为24小时，首次提交通
  • HarmonyOS Next ohpm-repo 权限管理与安全策略优化 harmonyos
    在企业级的HarmonyOSNext开发中，ohpm-repo私有仓库的安全性至关重要。它不仅关乎代码资产的保护，还影响着整个开发流程的稳定性。下面我们将从访问控制策略配置、公私钥认证以及安全优化与入侵防护等方面，详细探讨如何实现企业级安全策略，确保ohpm-repo私有仓库的安全性，防止未经授权访问。如何配置访问控制策略？通过ohpmconfigsetregistry绑定私有仓库在使用ohpm-
  • 【CMake指南】第5篇：跨平台配置与工具链（实现多环境无缝构建） JuicyActiveGilbert CMake指南嵌入式硬件单片机c++CMake教程
    本文中的相关代码、文件皆为示例。1.跨平台路径处理1.1统一路径分隔符#将路径转换为当前平台的格式file(TO_CMAKE_PATH"/usr/local/include"NORMALIZED_PATH)message("转换后路径:${NORMALIZED_PATH}")#Windows输出:usr\local\include1.2路径拼接最佳实践#错误方式（硬编码分隔符）set(INC_PA
  • IP证书如何让企业提升网络信任度 ssl证书ip地址
    IP证书，作为一种专门设计用于保护IP地址安全的数字证书，正逐渐成为提升企业网络信任度的关键工具。###IP证书申请入口申请时记得填写注册码230931，获取一对一技术支持一、身份验证与加密通信IP证书的核心在于通过PKI技术实现设备身份与IP地址的强绑定。当企业为服务器或设备部署IP证书后，通信双方通过交换证书验证身份，并协商对称密钥加密数据，确保通信的机密性与完整性。这一机制有效抵御了IP欺骗
  • 深度合成算法备案十大雷区拆解 AI产品备案 人工智能算法语言模型ai
    最近后台收到了很多小伙伴的私信，基本上都是在问算法备案被打回了；哪部分的材料有什么问题；不清楚驳回原因等等。今天结合大家最关心的问题，为大家详细剖析一下备案过程中常见的十大难题及解决方法。一、备案主体性质界定不明不少企业在备案过程中往往难以明确自身是否属于备案主体范围，尤其是涉及技术提供与应用服务的交叉领域，无法判断自身是否属于“具有舆论属性或者社会动员能力”主体。解决方案：仔细研读相关政策法规，
  • 如何减少跨团队交付摩擦？——基于 DevOps 与敏捷的最佳实践 pythonyaml
    摘要在现代软件开发中，跨团队协作的挑战主要体现在需求变更、测试环境不匹配、沟通不畅，这些问题往往导致交付延迟。本文将探讨如何通过DevOps、Scrum以及协作文档来提升跨团队协作效率，并提供可运行的Demo代码模块，帮助读者落地最佳实践。引言在企业软件开发中，产品、开发、测试、运维、设计团队之间的交付摩擦是常见问题。造成这些摩擦的核心原因包括：需求变更频繁：需求文档未同步，开发与产品理解偏差。测
  • 解锁健康密码：拥抱养生，重塑生活 yy0821yy 生活
    在当下，快节奏的生活如汹涌浪潮，裹挟着我们一路向前。高强度的工作、繁杂的生活琐事，让人们在忙碌中常常忽略了自身健康。然而，健康并非从天而降的幸运，而是精心呵护的成果，养生则是开启健康之门的钥匙。饮食养生是基石。俗话说：“病从口入。”合理的饮食结构对健康至关重要。多摄入富含膳食纤维的粗粮，像燕麦、糙米，它们能促进肠道蠕动，预防便秘，降低心血管疾病风险。新鲜的蔬果更是必不可少，菠菜、橙子等富含维生素与
  • 健康养生：活力生活的基石 yy0821yy 生活
    在当下，生活节奏快得像飞驰的列车，我们在忙碌里穿梭，愈发明白健康才是最珍贵的财富。健康养生可不是一阵风似的潮流，它实实在在是开启活力生活的关键，精心呵护着我们身体与心灵的方方面面。就拿饮食来说，这可是健康养生的根基。践行均衡饮食，就如同为身体精心筹备一场满汉全席。多吃那些颜色鲜艳的蔬菜，像绿油油的西兰花，它富含维生素与矿物质，给身体补充满满的营养；还有红彤彤的番茄，既能抗氧化，又美味可口。水果也不
  • 健康养生：滋养身心的生活智慧 yy0821yy 生活
    健康养生，是一场与身体和心灵的对话，是对生命细致入微的呵护，它贯穿于生活的点滴之中，为我们开启优质生活的大门。情志养生在健康养生中占据重要地位。人的情绪如同四季的天气，或晴或雨，但长期的负面情绪如狂风暴雨，会冲击身体的健康防线。我们要学会保持平和、乐观的心态。当遇到挫折时，把它视为成长的机遇，以积极的思维去化解困难。比如，工作上的项目失败了，可以从中总结经验，看到自己提升的空间，而不是一味自责。平
  • 数据产品赋能数字化转型 wengad 数字化转型数据产品人工智能大数据
    数据产品赋能数字化转型引言：数据产品的创新与发展：赋能决策智能化的钥匙一、数据产品的定义与特征二、数据产品的核心功能三、应用实践与案例分析四、未来展望引言：数据产品的创新与发展：赋能决策智能化的钥匙在数字化转型的浪潮下，数据已成为企业核心竞争力的关键要素。数据产品的出现，不仅是信息技术发展的必然产物，更是企业实现数据价值最大化、推动决策智能化的重要工具。本文旨在探讨数据产品的概念、功能特性、应用实
  • 33.从入门到精通：Python3 正则表达式 re.match函数 re.search方法 re.match与re.search的区别 摘星月为妆。 Python从入门到精通正则表达式
    33.从入门到精通：Python3正则表达式re.match函数re.search方法re.match与re.search的区别Python3正则表达式re.match函数re.search方法re.match与re.search的区别Python3正则表达式在Python3中，可以使用re模块来进行正则表达式的匹配和处理。以下是一个简单的例子，说明如何使用re模块进行正则表达式匹配：import
  • ICC2 实战秘籍：create_workspace 命令全解析 数字后端物理设计知识库 icc2命令每日精要后端性能优化
    在IC设计的江湖中，物理设计工程师们每天都在与各种工具和命令打交道，就像武侠高手手中的剑，熟练掌握这些工具和命令，才能在设计的战场上披荆斩棘。今天，就给大家带来一篇关于ICC2中create_workspace命令的实用解读，帮助大家更好地理解和运用这一强大工具。一、create_workspace的江湖地位create_workspace这个命令在ICC2的世界里可是举足轻重，它主要用于创建一个
  • innovus 命令每日精要 | setAnalysisMode：深度解析与高效配置指南 数字后端物理设计知识库 innovus命令每日精要人工智能后端性能优化
    在芯片设计领域，时序分析是确保设计可靠性和性能的关键环节，而Innovus作为业内领先的实现工具，其命令的精准运用直接决定了时序分析的效率与质量。今天，让我们一同深入探究setAnalysisMode这一核心命令，解锁其隐藏的潜力，为芯片设计之旅保驾护航。setAnalysisMode是Innovus工具中用于配置全局时序分析模式的核心命令，其作用涵盖分析类型设置、时钟传播控制、检查方式定义及优化
  • Python与Web 3.0：重新定义数字身份验证的未来 Echo_Wish Python！实战！python前端开发语言
    Python与Web3.0：重新定义数字身份验证的未来随着Web3.0的迅猛发展，传统的身份验证方式正面临越来越大的挑战。从依赖中心化服务器存储用户数据，到如今去中心化、用户掌控数据的新时代，身份验证系统经历了前所未有的变革。而作为一个人工智能、区块链和Python技术的深度爱好者，我认为Python将成为构建Web3.0身份验证系统的重要工具。今天，我们就来聊聊如何结合Python与Web3.0
  • 第七篇：数据治理实践工具与资源 小技工丨 数据治理网络数据库大数据数据治理
    1.数据治理实践工具与资源1.1数据治理成熟度评估工具数据治理成熟度评估是企业了解自身数据治理现状、识别改进机会的重要工具。通过系统化的评估，企业可以明确数据治理的发展阶段，制定有针对性的改进计划。1.1.1IBM数据治理成熟度评估模型IBM数据治理成熟度评估模型是业界广泛应用的评估工具之一，它从多个维度评估企业的数据治理成熟度。“数据被认为是推动企业增长和商业创新引擎的燃料。数据无疑被组织认定且
  • 大模型和数据要素赋能实体零售行业数字化转型建设和实施方案 优享智库 大模型数据要素数据治理数据仓库主数据零售
    大模型和数据要素赋能实体零售行业数字化转型建设和实施方案更多参考公众号：优享智库引言项目背景与意义数字化转型目标与期望实施方案概述零售行业现状及挑战实体零售行业现状数字化转型面临的挑战市场需求与趋势分析大模型与数据要素赋能策略大模型技术及应用场景数据要素采集、整合与治理赋能策略制定与实施路径数字化转型关键技术与解决方案人工智能技术及应用大数据分析与挖掘技术云计算、物联网等技术支持定制化解决方案设计
  • c++与c语言的区别是什么？ pythoncainiao221 c++c语言开发语言
    1、类型不同C语言是面向过程的，而C++是面向对象的。2、函数库不同C语言的标准的函数库很松散，而C++对于大多数的函数都是集成的很紧密。3、结构不同C语言中结构只有成员变量，而在C++中结构中，可以有成员变量和成员函数。它们的区别是c++是在C语言基础上发展起来的，根据开发过程中遇到的需求，它引入了很多新的特性。如果你不走C/C++方向，直接学习Java就可以了，相同的待遇下，选择简单的更好。当
  • 网络华为HCIA+HCIP网络基础 ssr——ssss 华为网络
    目录通信与网络基础网络类型和网络拓扑网络参考模型和标准协议VRP文件系统命令行试图使用快捷键网工基础命令文件系统基本配置命令通信与网络基础通信，是指人与人、人与物、物与物之间通过某种媒介和行为进行的信息传递与交流。网络通信，是指终端设备之间通过计算机网络进行的通信。交换机:距离终端用户最近的设备，用于终端用户接入网络、对数据帧进行交换等。路由器:网络层设备，可以在因特网中进行数据报文转发。路由器根
  • 荣耀CEO赵明内网发布告别文章，正式告别荣耀和职场 国货崛起 其他智能手机智能硬件
    2025年1月17日，荣耀终端有限公司CEO赵明在内部论坛发布长文，正式宣布告别荣耀和职场。这封告别信在荣耀内部引发强烈反响，员工们纷纷留言表达不舍与祝福。赵明在信中回顾了他在荣耀的职业生涯。2015年，他从华为消费者业务CMO调任荣耀总裁，带领荣耀从互联网手机品牌发展成为全球领先的智能终端提供商。在任期间，他主导了荣耀品牌的独立运营，成功打造了荣耀Magic系列、数字系列等多款爆款产品，使荣耀在
  • 【大模型开发】大模型转换为 NCNN 格式并在 微信小程序 中进行调用 云博士的AI课堂 大模型技术开发与实践哈佛博后带你玩转机器学习深度学习微信小程序小程序NCNN小程序调用大模型大模型部署大模型优化部署微信小程序
    以下内容将介绍如何将大模型转换为NCNN格式并在微信小程序中进行调用。我们会从整体流程、模型转换工具、NCNNWebAssembly（WASM）编译与集成、小程序前端代码示例等方面进行详细讲解，并在最后给出优化方向与未来建议。目录背景与整体流程概述准备工作2.1常见模型格式与转换思路2.2环境与工具安装模型转换为NCNN格式3.1以ONNX模型为例3.2使用onnx2ncnn工具NCNN在微信小程
  • Ghostscript 简介与使用指南 gs80140 pdf
    目录Ghostscript简介与使用指南1.什么是Ghostscript？2.Ghostscript的安装2.1在Windows上安装2.2在macOS上安装（使用Homebrew）2.3在Linux上安装（Ubuntu/Debian）3.Ghostscript的基本用法3.1查看PDF或PostScript文件3.2将PDF转换为PNG/JPEG3.3压缩PDF文件3.4合并多个PDF文件3.5
  • 从LLM出发：由浅入深探索AI开发的全流程与简单实践（全文3w字） 码事漫谈 AI人工智能
    文章目录第一部分：AI开发的背景与历史1.1人工智能的起源与发展1.2神经网络与深度学习的崛起1.3Transformer架构与LLM的兴起1.4当前AI开发的现状与趋势第二部分：AI开发的核心技术2.1机器学习：AI的基础2.1.1机器学习的类型2.1.2机器学习的流程2.2深度学习：机器学习的进阶2.2.1神经网络基础2.2.2深度学习的关键架构2.3Transformer架构：现代LLM的核
  • P=NP问题 太翌修仙笔录 deepseek超算法认知架构人工智能知识图谱算法重构
    P=NP是什么难题P=NP问题是计算机科学和数学领域中一个著名的未解难题，涉及计算复杂性理论的核心内容。以下是对该问题的详细分析：###**1.P与NP的定义**-**P类（PolynomialTime）**：包含所有能在多项式时间内被**确定性图灵机**解决的决策问题。例如，排序、最短路径问题等均属于P类。-**NP类（NondeterministicPolynomialTime）**：包含所有
  • 构造函数的分类 cuikebinpau c++开发语言
    C++构造函数的分类与调用方式详解在C++中，构造函数（Constructor）是类的特殊成员函数，在对象创建时自动调用，用于对对象进行初始化。根据使用场景和实现方式，构造函数可以分为不同的类型，且调用方式也各有不同。本文将详细介绍C++构造函数的分类及其调用方式。1.1默认构造函数（无参构造函数）定义：默认构造函数是不带参数的构造函数，在创建对象时会自动调用。如果程序员没有定义任何构造函数，编译
  • Windows 发票闪印 PrintPDF-v3.6.10-第三方发票打印辅助工具，无需安装阅读器即可使用 私人珍藏库 winPrintPDF发票闪印
    PrintPDF_发票闪印链接：https://pan.xunlei.com/s/VOLCPVsJiYRh9GDPHK_jd5ZoA1?pwd=b399#使用说明：1、文件导入数量不限，但单个文件限制是10页。支持PDF、OFD和图片版电子发票（非以上三种文件会自动跳过）。文件导入方式：可在软件界面将文件拖入；可将文件拖至与PrintPDF.exe快捷方式或PrintPDF.exe可执行文件处导入
  • 基于GPT架构的视频生成工具（VideoGPT） deepdata_cn 视频生成音视频视频生成
    VideoGPT是基于GPT架构的视频生成工具，支持从文本生成视频。最初，研究人员尝试将自然语言处理中的GPT架构思想引入视频处理领域，开始探索如何利用其强大的语言理解和生成能力来处理视频的时空信息。模型改进与创新：如VideoGPT+模型结合了先进的图像编码器和视频编码器，克服了传统方法在处理视频时的局限，在捕捉丰富空间细节和理解复杂时间动态上展现出卓越性能。iVideoGPT采用新颖的压缩to
  • DeepSeek 在代码生成方面的优势解析 草莓屁屁我不吃 人工智能aichatgpt
    在AI代码生成领域，DeepSeek通过其DeepSeek-Coder模型展现出强大的能力，与OpenAI的Codex、Meta的CodeLlama、Google的AlphaCode等国际领先模型同台竞争。文章将详细解析DeepSeek在代码生成方面的优势，包括模型架构、数据训练、优化策略、编程语言支持、推理效率等核心技术点。1.DeepSeek-Coder的模型架构优化DeepSeek-Code
  • 使用OpenResty（基于Nginx和Lua）优化Web服务性能 随风九天 部署运维java性能九阴白骨爪openrestynginxlua
    引言1.1OpenResty简介OpenResty是一个基于Nginx和Lua的高性能Web应用平台。它通过将Lua脚本嵌入到Nginx中，提供了强大的动态处理能力，适用于构建高性能的Web服务、API网关、动态内容生成等场景。1.2Nginx与Lua结合的优势高性能：Nginx本身就是一个高性能的HTTP和反向代理服务器，而Lua的嵌入使得动态处理能力大大增强。低资源消耗：Lua脚本的执行效率高
  • 面试视角深度解析：索引冗余 vs 覆盖索引 vs 全表扫描的终极抉择 dblens 数据库管理和开发工具 mysql面试java数据库
    一、核心概念解析（面试破题关键）1.索引冗余（IndexRedundancy）本质：同一字段存在多个重复或包含关系的索引典型场景重复索引：INDEX(a)和INDEX(a)前缀冗余：已有INDEX(a,b,c)时再建INDEX(a,b)隐式覆盖：主键索引与唯一索引的列重叠面试考点如何通过SHOWINDEX识别冗余索引冗余索引对写性能的影响公式：写入耗时=基础耗时×(索引数+1)存储成本计算：单个索
  • tomcat基础与部署发布 暗黑小菠萝 Tomcat java web
    从51cto搬家了，以后会更新在这里方便自己查看。 做项目一直用tomcat，都是配置到eclipse中使用，这几天有时间整理一下使用心得，有一些自己配置遇到的细节问题。 Tomcat：一个Servlets和JSP页面的容器，以提供网站服务。 一、Tomcat安装     安装方式：①运行.exe安装包      &n
  • 网站架构发展的过程 ayaoxinchao 数据库应用服务器网站架构
    1.初始阶段网站架构：应用程序、数据库、文件等资源在同一个服务器上 2.应用服务和数据服务分离：应用服务器、数据库服务器、文件服务器 3.使用缓存改善网站性能：为应用服务器提供本地缓存，但受限于应用服务器的内存容量，可以使用专门的缓存服务器，提供分布式缓存服务器架构 4.使用应用服务器集群改善网站的并发处理能力：使用负载均衡调度服务器，将来自客户端浏览器的访问请求分发到应用服务器集群中的任何
  • [信息与安全]数据库的备份问题 comsci 数据库
          如果你们建设的信息系统是采用中心-分支的模式,那么这里有一个问题   如果你的数据来自中心数据库,那么中心数据库如果出现故障,你的分支机构的数据如何保证安全呢?    是否应该在这种信息系统结构的基础上进行改造,容许分支机构的信息系统也备份一个中心数据库的文件呢?  &n
  • 使用maven tomcat plugin插件debug关联源代码 商人shang mavendebug查看源码tomcat-plugin
    *首先需要配置好'''maven-tomcat7-plugin'''，参见[[Maven开发Web项目]]的'''Tomcat'''部分。 *配置好后，在[[Eclipse]]中打开'''Debug Configurations'''界面，在'''Maven Build'''项下新建当前工程的调试。在'''Main'''选项卡中点击'''Browse Workspace...'''选择需要开发的
  • 大访问量高并发 oloz 大访问量高并发
    大访问量高并发的网站主要压力还是在于数据库的操作上，尽量避免频繁的请求数据库。下面简 要列出几点解决方案： 01、优化你的代码和查询语句，合理使用索引 02、使用缓存技术例如memcache、ecache将不经常变化的数据放入缓存之中 03、采用服务器集群、负载均衡分担大访问量高并发压力 04、数据读写分离 05、合理选用框架，合理架构(推荐分布式架构)。
  • cache 服务器 小猪猪08 cache
    Cache   即高速缓存.那么cache是怎么样提高系统性能与运行速度呢？是不是在任何情况下用cache都能提高性能？是不是cache用的越多就越好呢？我在近期开发的项目中有所体会，写下来当作总结也希望能跟大家一起探讨探讨，有错误的地方希望大家批评指正。 　　1.Cache   是怎么样工作的? 　　Cache   是分配在服务器上
  • mysql存储过程 香水浓 mysql
    Description:插入大量测试数据 use xmpl; drop procedure if exists mockup_test_data_sp; create procedure mockup_test_data_sp( in number_of_records int ) begin declare cnt int; declare name varch
  • CSS的class、id、css文件名的常用命名规则 agevs JavaScriptUI框架Ajaxcss
      CSS的class、id、css文件名的常用命名规则     (一)常用的CSS命名规则 　　头：header 　　内容：content/container 　　尾：footer 　　导航：nav 　　侧栏：sidebar 　　栏目：column 　　页面外围控制整体布局宽度：wrapper 　　左右中：left right
  • 全局数据源 AILIKES javatomcatmysqljdbcJNDI
    实验目的：为了研究两个项目同时访问一个全局数据源的时候是创建了一个数据源对象，还是创建了两个数据源对象。 1：将diuid和mysql驱动包（druid-1.0.2.jar和mysql-connector-java-5.1.15.jar）copy至%TOMCAT_HOME%/lib下；2：配置数据源，将JNDI在%TOMCAT_HOME%/conf/context.xml中配置好,格式如下：&l
  • MYSQL的随机查询的实现方法 baalwolf mysql
    MYSQL的随机抽取实现方法。举个例子，要从tablename表中随机提取一条记录，大家一般的写法就是：SELECT * FROM tablename ORDER BY RAND() LIMIT 1。但是，后来我查了一下MYSQL的官方手册，里面针对RAND()的提示大概意思就是，在ORDER BY从句里面不能使用RAND()函数，因为这样会导致数据列被多次扫描。但是在MYSQL 3.23版本中，
  • JAVA的getBytes()方法 bijian1013 javaeclipseunixOS
        在Java中，String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组。这个表示在不同OS下，返回的东西不一样！      String.getBytes(String decode)方法会根据指定的decode编码返回某字符串在该编码下的byte数组表示，如： byte[] b_gbk = "
  • AngularJS中操作Cookies bijian1013 JavaScriptAngularJSCookies
            如果你的应用足够大、足够复杂，那么你很快就会遇到这样一咱种情况：你需要在客户端存储一些状态信息，这些状态信息是跨session(会话)的。你可能还记得利用document.cookie接口直接操作纯文本cookie的痛苦经历。         幸运的是，这种方式已经一去不复返了，在所有现代浏览器中几乎
  • [Maven学习笔记五]Maven聚合和继承特性 bit1129 maven
    Maven聚合   在实际的项目中，一个项目通常会划分为多个模块，为了说明问题，以用户登陆这个小web应用为例。通常一个web应用分为三个模块： 1. 模型和数据持久化层user-core, 2. 业务逻辑层user-service以 3. web展现层user-web， user-service依赖于user-core user-web依赖于user-core和use
  • 【JVM七】JVM知识点总结 bit1129 jvm
      1. JVM运行模式 1.1 JVM运行时分为-server和-client两种模式，在32位机器上只有client模式的JVM。通常，64位的JVM默认都是使用server模式，因为server模式的JVM虽然启动慢点，但是，在运行过程，JVM会尽可能的进行优化 1.2 JVM分为三种字节码解释执行方式：mixed mode, interpret mode以及compiler
  • linux下查看nginx、apache、mysql、php的编译参数 ronin47
    在linux平台下的应用，最流行的莫过于nginx、apache、mysql、php几个。而这几个常用的应用，在手工编译完以后，在其他一些情况下（如：新增模块），往往想要查看当初都使用了那些参数进行的编译。这时候就可以利用以下方法查看。 1、nginx [root@361way ~]# /App/nginx/sbin/nginx -V nginx: nginx version: nginx/
  • unity中运用Resources.Load的方法？ brotherlamp unity视频unity资料unity自学unityunity教程
    问：unity中运用Resources.Load的方法？ 答：Resources.Load是unity本地动态加载资本所用的方法,也即是你想动态加载的时分才用到它,比方枪弹,特效,某些实时替换的图像什么的,主张此文件夹不要放太多东西,在打包的时分,它会独自把里边的一切东西都会集打包到一同,不论里边有没有你用的东西,所以大多数资本应该是自个建文件放置 1、unity实时替换的物体即是依据环境条件
  • 线段树-入门 bylijinnan java算法线段树
    /** * 线段树入门 * 问题：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次 * 以下代码建立的线段树用链表来保存，且树的叶子结点类似[i,i] * * 参考链接：http://hi.baidu.com/semluhiigubbqvq/item/be736a33a8864789f4e4ad18 * @author lijinna
  • 全选与反选 chicony 全选
      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>全选与反选</title>
  • vim一些简单记录 chenchao051 vim
    mac在/usr/share/vim/vimrc linux在/etc/vimrc   1、问：后退键不能删除数据，不能往后退怎么办？       答：在vimrc中加入set backspace=2   2、问：如何控制tab键的缩进？       答：在vimrc中加入set tabstop=4 (任何
  • Sublime Text 快捷键 daizj 快捷键sublime
    [size=large][/size]Sublime Text快捷键：Ctrl+Shift+P：打开命令面板Ctrl+P：搜索项目中的文件Ctrl+G：跳转到第几行Ctrl+W：关闭当前打开文件Ctrl+Shift+W：关闭所有打开文件Ctrl+Shift+V：粘贴并格式化Ctrl+D：选择单词，重复可增加选择下一个相同的单词Ctrl+L：选择行，重复可依次增加选择下一行Ctrl+Shift+L：
  • php 引用(&)详解 dcj3sjt126com PHP
    在PHP 中引用的意思是：不同的名字访问同一个变量内容. 与Ｃ语言中的指针是有差别的．Ｃ语言中的指针里面存储的是变量的内容在内存中存放的地址 变量的引用 PHP 的引用允许你用两个变量来指向同一个内容  复制代码代码如下: <?  $a="ABC";  $b =&$a;  echo
  • SVN中trunk,branches,tags用法详解 dcj3sjt126com SVN
    Subversion有一个很标准的目录结构，是这样的。比如项目是proj，svn地址为svn://proj/，那么标准的svn布局是svn://proj/|+-trunk+-branches+-tags这是一个标准的布局，trunk为主开发目录，branches为分支开发目录，tags为tag存档目录（不允许修改）。但是具体这几个目录应该如何使用，svn并没有明确的规范，更多的还是用户自己的习惯。
  • 对软件设计的思考 e200702084 设计模式数据结构算法ssh活动
    软件设计的宏观与微观    软件开发是一种高智商的开发活动。一个优秀的软件设计人员不仅要从宏观上把握软件之间的开发，也要从微观上把握软件之间的开发。宏观上，可以应用面向对象设计，采用流行的SSH架构，采用web层，业务逻辑层，持久层分层架构。采用设计模式提供系统的健壮性和可维护性。微观上，对于一个类，甚至方法的调用，从计算机的角度模拟程序的运行情况。了解内存分配，参数传
  • 同步、异步、阻塞、非阻塞 geeksun 非阻塞
    同步、异步、阻塞、非阻塞这几个概念有时有点混淆，在此文试图解释一下。   同步：发出方法调用后，当没有返回结果，当前线程会一直在等待（阻塞）状态。 场景：打电话，营业厅窗口办业务、B/S架构的http请求-响应模式。   异步：方法调用后不立即返回结果，调用结果通过状态、通知或回调通知方法调用者或接收者。异步方法调用后，当前线程不会阻塞，会继续执行其他任务。 实现：
  • Reverse SSH Tunnel 反向打洞實錄 hongtoushizi ssh
    實際的操作步驟： # 首先，在客戶那理的機器下指令連回我們自己的 Server，並設定自己 Server 上的 12345 port 會對應到幾器上的 SSH port ssh -NfR 12345:localhost:22 [email protected] # 然後在 myhost 的機器上連自己的 12345 port，就可以連回在客戶那的機器 ssh localhost -p 1
  • Hibernate中的缓存 Josh_Persistence 一级缓存Hiberante缓存查询缓存二级缓存
    Hibernate中的缓存   一、Hiberante中常见的三大缓存：一级缓存，二级缓存和查询缓存。 Hibernate中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存是由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存
  • 对象关系行为模式之延迟加载 home198979 PHP架构延迟加载
    形象化设计模式实战     HELLO!架构   一、概念 Lazy Load：一个对象，它虽然不包含所需要的所有数据，但是知道怎么获取这些数据。 延迟加载貌似很简单，就是在数据需要时再从数据库获取，减少数据库的消耗。但这其中还是有不少技巧的。     二、实现延迟加载 实现Lazy Load主要有四种方法：延迟初始化、虚
  • xml 验证 pengfeicao521 xmlxml解析
    有些字符，xml不能识别，用jdom或者dom4j解析的时候就报错 public static void testPattern() { // 含有非法字符的串 String str =       "Jamey&#52828;&#01;&#02;&#209;&#1282
  • div设置半透明效果 spjich css半透明
    为div设置如下样式：   div{filter:alpha(Opacity=80);-moz-opacity:0.5;opacity: 0.5;}        说明： 1、filter：对win IE设置半透明滤镜效果，filter:alpha(Opacity=80)代表该对象80%半透明，火狐浏览器不认2、-moz-opaci
  • 你真的了解单例模式么？ w574240966 java单例设计模式jvm
        单例模式，很多初学者认为单例模式很简单，并且认为自己已经掌握了这种设计模式。但事实上，你真的了解单例模式了么。   一，单例模式的5中写法。（回字的四种写法，哈哈。）     1，懒汉式           （1）线程不安全的懒汉式 public cla