王劭阳
王劭阳

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)

  • DeepSeek 与云原生后端：AI 赋能现代应用架构 一ge科研小菜菜 后端人工智能后端
    个人主页：一ge科研小菜鸡-CSDN博客期待您的关注1.引言在当今快速发展的互联网时代，云原生（CloudNative）架构已成为后端开发的主流趋势。云原生后端的核心目标是利用云计算的弹性、可扩展性和高可用性，为现代应用提供稳定可靠的后端支持。而人工智能（AI）技术的发展，使得智能化成为云原生后端的新趋势。DeepSeek作为新一代AI技术，在云原生后端的自动化运维、智能资源调度、安全增强和高效数
  • java数组 TwitCoder java算法
    目录一、数组概念二、数组的声明与初始化三、数组操作示例四、数组属性与注意事项五、内存结构分析六、常见操作七、二维数组八、稀疏数组一、数组概念数组是Java中用于存储相同类型数据的有序集合，具有以下特性：类型一致性：所有元素必须属于同一数据类型有序性：元素按顺序排列，通过索引访问长度固定：创建后无法改变容量二、数组的声明与初始化声明数组//推荐写法int[]numbers;初始化方式：动态初始化nu
  • 【Attention】SEAttention shanks66 Attention各种深度学习模块人工智能深度学习python
    SEAttention摘要卷积神经网络（CNNs）的核心构建模块是卷积算子，它使网络能够通过在每一层的局部感受野内融合空间和通道信息来构建有价值的特征。此前大量研究聚焦于这种关系中的空间成分，试图通过在整个特征层级中提升空间编码质量来增强CNN的表征能力。在这项工作中，我们将重点放在通道关系上，并提出一种新颖的架构单元，称为“挤压与激励”（Squeeze-and-Excitation，简称SE）模
  • @Component—@Autowired—@Mapper—@Bean 追JAVA的小菜鸟 零碎知识点beanjavamybatisspringcomponent
    注解详解一、@Component二、@Autowired注解支持context:annotation-config——手动注入beancontext:component-scanbase-package="zy.pojo"——扫描包并自动注入总结三、@Mapper@Mapper与@Repository四、@Bean@Bean与@Component区别一、@Component作用：表明了此类为一个组
  • 【C++游戏开发】零基础手写完整飞机大战游戏（基于EasyX图形库/详细注释/源码分享） 小乌龟登顶记 stm32单片机嵌入式硬件
    一、开发环境与资源准备1.1环境要求VisualStudio2019+（推荐2022）EasyX图形库（官网下载适配VS版本）WindowsSDK（安装VS时勾选）1.2资源文件在项目目录创建res文件夹，存放以下素材（素材自备）：plane.png玩家飞机（50x50）enemy.png敌机（50x50）bullet.png子弹（10x20）bg.jpg滚动背景（600x700）boom.wav
  • AI 大模型应用数据中心建设：高性能计算与存储架构 AI智能涌现深度研究 AI大模型应用入门实战与进阶javapythonjavascriptkotlingolang架构人工智能
    AI大模型、数据中心、高性能计算、存储架构、分布式训练、GPU加速、数据管理1.背景介绍近年来，人工智能（AI）技术取得了飞速发展，特别是深度学习模型的突破性进展，催生了一系列基于大规模数据训练的强大AI模型，例如GPT-3、BERT、DALL-E等。这些AI大模型在自然语言处理、计算机视觉、语音识别等领域展现出强大的应用潜力，但也对计算资源和数据存储提出了极高的要求。传统的计算架构难以满足AI大
  • JavaScript 全面教程：从基础到高级实践 幼儿园扛把子\ javascript开发语言ecmascript
    JavaScript全面教程：从基础到高级实践目录JavaScript全面教程：从基础到高级实践2.JavaScript基础语法2.1变量与数据类型2.1.1变量声明2.1.2数据类型2.2条件语句与循环2.2.1条件语句2.2.2循环2.3函数2.3.1函数定义2.3.2参数默认值3.对象与数组3.1对象3.2数组4.高级特性与最佳实践4.1作用域与闭包4.1.1闭包示例4.2事件循环（Even
  • 加固与脱壳05 - 壳类型识别 二手的程序员 加固与脱壳网络安全安全网络开发语言前端
    以前一些老旧的技术就不介绍了，比如，动态加载、内存不落地加载的方式。现在的加壳类型分为3种：指令抽取VMPdexc2chttps://www.dingxiang-inc.com/blog/post/2指令抽取android的指令抽取，主要在于函数基本的抽取保护。通过使用android虚拟机自带的解释器进行执行代码。将原始App中dex文件的函数内容进行清除，并将单独移动到一个加密文件中，在App运
  • 一篇文章带你学完Java所有的时间与日期类 MHP小喇叭 java开发语言
    目录一、传统时间与日期类1.Date类构造方法获取日期和时间信息的方法设置日期和时间信息的方法2.Calendar类主要特点和功能常用方法1.获取当前日历对象2.获取日历中的某个信息3.获取日期对象4.获取时间毫秒值5.修改日历的某个信息6.为某个信息增加或者减少值3.SimpleDateFormat类主要用途构造函数模式字符串将日期格式化成日期与时间字符串将时间毫秒值格式化成字符串解析日期示例要
  • 托盘四向车与子母车对比 骞途 笔记人工智能经验分享
    在同等仓库面积和建筑高度的条件下，托盘四向穿梭车与托盘子母车在存储托盘数量、作业效率、性价比等方面存在显著差异。以下从多个维度进行对比分析：1.存储托盘数量四向穿梭车：四向穿梭车可在货架平面内任意方向行驶（前后、左右、换轨），无需额外转弯空间，货架布局更紧凑，存储密度更高。其支持交叉轨道设计，且可灵活到达任意货位，空间利用率可达80%-90%。例如，在多层货架系统中，通过提升机配合，四向车可覆盖全
  • 融合网络实训室初步建设方案设想 武汉唯众智创 网络融合网络实训室融合网络融合网络实验室网络融合实训室网络融合实验室
    一、引言在数字化浪潮席卷全球的当下，网络技术已然成为推动社会发展和经济增长的关键力量。从日常的生活购物到企业的运营管理，从便捷的社交沟通到前沿的科研探索，网络技术无处不在，深刻地改变着人们的生活与工作方式。随着5G、物联网、云计算、大数据等新兴技术的迅猛发展，网络技术领域对于专业人才的需求呈现出爆发式增长。据权威机构预测，未来几年，网络技术相关岗位的人才缺口将持续扩大。这些岗位不仅要求从业者具备扎
  • 【11】单片机编程核心技巧：进制玄机 智木芯语 单片机嵌入式硬件
    【11】单片机编程核心技巧：进制玄机七律·进制玄机二进根基硬件生，八灯辉映万千形。字节八位藏寰宇，变量范围定始终。十六缩影通寄存，十进直观映真容。实验验证真理明，编程妙用万象成。摘要本文系统阐述了单片机编程中二进制、十六进制与十进制的转换方法及其应用。首先，从硬件基础出发，分析了二进制在数字电路中的核心地位，并结合变量位数与取值范围的实例，揭示了二进制在数据存储与运算中的重要性。其次，通过十六进制
  • 中断向量表 Cold_Johnsnow stm32arm体系结构与编程驱动arm开发驱动开发
    中断向量表（InterruptVectorTable,IVT）是单片机（或处理器）中实现中断机制的核心数据结构，其作用类似于硬件与中断服务程序（ISR）之间的"导航地图"。它直接决定了系统在中断触发时如何快速定位到对应的处理代码。以下从技术原理、实现机制和应用设计三个层面进行深度解析：硬件级工作原理物理存储结构中断向量表存储在内存的固定起始地址（如ARMCortex-M固定在0x08000000，
  • 【西安电子科技大学考研】25官方复试专业课参考书目汇总 西电研梦 考研西电经验分享面试西安电子科技大学
    初试已经顺利考完啦、成绩已经公布，现在已经有很多同学来问学长学姐，复试参考书有哪些，复试应该做好哪些准备。故此学长学姐给大家整理好了西安电子科技大学各个学院的复试参考书目录，有需要的同学可以参考一下哈。大家可以结合本篇文章内容与招生目录参考书对比一下：【西电考研复试资料、讲课班陆续上线中~~~】有的参考书更新了版本，但是招生目录里仍然是之前的一些旧版本，关于参考书的版本问题，大家也可以在群内问一下
  • 西安电子科技大学 | 近期官方视频＋文章（涵盖招生＋录取统计） 西电研梦 西电经验分享考研
    今年、明年考研的学弟学妹们可以看看涵盖今年讲课西电录取统计【西安电子科技大学官方】研究生招生宣传你一定值得一看02、计算机科学与技术学院（近期视频＋文章）QQ群：867684593①、西电考研|833、834初+复试第一名许学长经验分享https://www.bilibili.com/video/BV1oE4m1R72a/②、25西电考研|计科院专业课139分学长经验分享https://www.b
  • 西安电子科技大学考研833计算机专业基础综合初试备考经验 西电研梦 考研
    本人21考研，报考西安电子科技大学。初试分数345。本科211机电专业，去年毕业出国受阻因此6月决定跨考西电计算机学硕833。回想自己备考的经历，有一些经验与不足之处，在这里分享给大家，尤其是一些跨考的同学。本次分别介绍数学、英语、政治、专业课、复试经历五部分。数学:数学和专业课是初试四门中最为重要的两门，决定能不能考上研基本就看这两门的复习情况!因为西电专硕学硕都是考察数学一，所以不需要考虑是否
  • rStar论文精读 MoyiTech 推理模型OpenAI-O1原理
    论文简介论文标题：《MutualreasoningmakessmallerLLMsstrongerproblem-solvers》论文地址：https://arxiv.org/abs/2408.06195录用会议：ICLR2025背景与挑战挑战1：在SLM中平衡exploration与exploitation。一些方法有很大的exploitation但限制任务多样性泛化性不好；一些方法有很大的ex
  • Hive SQL 精进系列：REGEXP_REPLACE 函数的用法 进一步有进一步的欢喜 HiveSQL精进系列hivesqlhadoop
    目录一、引言二、REGEXP_REPLACE函数基础2.1基本语法参数详解2.2简单示例三、REGEXP_REPLACE函数的应用场景3.1去除特殊字符3.2统一字符串格式四、REGEXP_REPLACE与REPLACE函数的对比4.1功能差异4.2适用场景五、REGEXP_REPLACE与REGEXP函数的对比5.1功能差异5.2适用场景六、总结一、引言字符串处理是数据处理中的常见需求，Hive
  • 嵌入式Linux网络编程实战：基于DNS解析的HTTP客户端实现 银河码 Linux网络编程网络linuxhttpc语言windowsvscodejson
    嵌入式Linux网络编程实战：基于DNS解析的HTTP客户端实现【本文代码已在树莓派4B（Linux内核5.10）平台验证通过，适用于物联网设备数据上报等场景】一、需求场景与功能亮点1.1典型物联网通信场景嵌入式设备DNS服务器云服务器域名解析请求返回目标IP发送传感器数据返回HTTP响应嵌入式设备DNS服务器云服务器1.2代码核心功能DNS智能解析：支持域名自动转换为IPv4地址协议合规性：严格
  • 在使用selenium进行爬虫时， add_experimental_optio(),add_argument()的用法 数据牧马人 selenium爬虫测试工具
    driver.add_experimental_option('excludeSwitches',['enable-automation'])是在使用SeleniumWebDriver与浏览器交互时设置的一行代码。这行代码用于禁用浏览器中的自动化检测。具体来说，当你在使用SeleniumWebDriver与浏览器交互时，有些浏览器（例如GoogleChrome）可能会检测到自动化行为（例如，通过检
  • 计算机信息安全 若水心境 软件架构师知识库信息安全
    等保2.0与等保1.0区别※等保2.0在2019年12月1日正式实施。等级保护制度2.0在1.0的基础上，注重全方位主动防御、动态防御、整体防控和精准防护，实现对云计算、移动互联网、物联网、工业控制信息系统等保护对象全覆盖。对象范围扩大将云计算、移动互联网、物联网、工业控制系统等技术列入标准中。分类结构统一“基本要求、设计要求和测评要求”分类框架统一，形成了“安全通信网络”、“安全区域边界”、“安
  • CVE-2017-5645(使用 docker 搭建) JM丫 网络安全
    介绍:是一个与ApacheLog4j2相关的安全漏洞,属于远程代码执行,它可能允许攻击者通过构造恶意的日志信息在目标系统上执行任意代码Log4j2介绍Log4j2是Apache的一个日志记录工具,属于Java应用的日志框架,它是Log4j的升级版,性能更好,功能更多.它被广泛的适用于Java应用程序中,帮助开发者记录程序运行的时候的日子信息,是Java生态系统中最重要的一个日志框架之一漏洞编号:C
  • 浩方wms:什么是海外仓WMS系统?作用是什么？ haofang_software 大数据个人开发sass数据库科技
    浩方动力科技认为，海外仓作为连接卖家与海外消费者的关键节点，其重要性愈发凸显。海外仓WMS系统（WarehouseManagementSystem），作为一种专门针对海外仓运营的信息化管理系统，正成为提升海外仓运营效率和服务水平的得力助手。什么是海外仓WMS系统呢？海外仓管理系统又有什么作用？浩方WMS，今天来为大家讲解一下海外仓WMS的作用和意义。海外仓WMS系统，顾名思义，是专为海外仓储业务设
  • 【前端入门】应该了解和知道的几个国内外前端开发资源网站 爱上大树的小猪 前端
    与大家分享一下几个国内外前端开发资源网站国际资源MDNWebDocs(MozillaDeveloperNetwork)用途：MDN是Web技术领域最全面的文档库之一，涵盖了HTML、CSS、JavaScript以及浏览器API等。链接:https://developer.mozilla.orgW3Schools用途：适合初学者学习Web技术，提供从基础到进阶的教程，同时还有在线练习环境。链接:ht
  • Python（1）Python全方位指南：定义、应用与零基础入门实战 一个天蝎座 白勺 程序猿 Python入门到精通python开发语言
    背景：为什么Python成为开发者必备技能？‌Python自1991年发布以来，凭借‌“简单高效”‌的设计理念，成为全球增长最快的编程语言。根据TIOBE2023年榜单，Python稳居前三，其核心竞争力包括：‌开发效率高‌：代码量仅为Java的1/5，C++的1/10。‌跨领域通吃‌：从Web开发到AI训练，覆盖90%以上技术场景。‌企业级应用‌：YouTube用Python处理视频推荐，NAS
  • Python 赋能经济趋势与股票研究：数据驱动的投资洞察 Small踢倒coffee_氕氘氚 笔记经验分享
    在当今数据爆炸的时代，Python凭借其强大的数据处理能力和丰富的开源库，已成为经济趋势分析和股票研究的利器。本文将探讨如何利用Python进行以下方面的研究：**一、数据获取与清洗*****数据来源:*****财经数据API:**Tushare、AKShare、YahooFinance、AlphaVantage等提供丰富的股票、基金、宏观经济等数据。***网络爬虫:**使用BeautifulSo
  • 鸿蒙开发2024【面试题库】讲解，近期需要面试的可千万别错过！ 鸿蒙系统小能手Mr.Li 鸿蒙开发harmonyos面试鸿蒙OpenHarmony鸿蒙系统程序员移动开发
    1.请简述鸿蒙OS与AndroidOS的主要区别是什么？设备兼容性：鸿蒙OS是一款面向各种设备的分布式操作系统，支持手机、平板电脑、智能手表、智能家居、汽车等多种设备类型，并能在这些设备之间实现无缝切换和共享数据。而Android系统则主要用于移动设备，如手机和平板电脑。系统架构：鸿蒙OS采用分布式技术架构，通过分布式技术实现多设备间的协作和数据共享，更加灵活、安全、高效。而Android则采用单
  • AI大模型从入门到精通，2025终极指南！好卷啊，又不能躺平，只能悄悄卷你们了！ 大模型教程 人工智能大模型训练LLM知识库大模型大模型入门大模型学习
    什么是AI大模型？AI大模型是指使用大规模数据和强大的计算能力训练出来的人工智能模型。这些模型通常具有高度的准确性和泛化能力，可以应用于各种领域，如自然语言处理、图像识别、语音识别等。为什么要学AI大模型？2024人工智能大模型的技术岗位与能力培养随着人工智能技术的迅速发展和应用，大模型作为其中的重要组成部分，正逐渐成为推动人工智能发展的重要引擎。大模型以其强大的数据处理和模式识别能力，广泛应用于
  • 零信任架构 阿湯哥 架构
    零信任架构（ZeroTrustArchitecture,ZTA）零信任架构是一种新型网络安全模型，核心理念是“永不信任，始终验证”（NeverTrust,AlwaysVerify）。它摒弃传统基于边界的安全防护（如防火墙隔离内外部网络），转而通过动态的、细粒度的访问控制，对所有用户、设备和数据流进行持续验证，最小化攻击面并防范内部威胁。一、零信任与传统安全模型的对比维度传统安全模型零信任模型信任基
  • hive-进阶版-1 数据牧马人 hivehadoop数据仓库
    第6章hive内部表与外部表的区别Hive是一个基于Hadoop的数据仓库工具，用于对大规模数据集进行数据存储、查询和分析。Hive支持内部表（ManagedTable）和外部表（ExternalTable）两种表类型，它们在数据存储、管理方式和生命周期等方面存在显著区别。以下是内部表和外部表的主要区别：1.数据存储位置内部表：数据存储在Hive的默认存储目录下，通常位于HDFS（HadoopDi
  • 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