王劭阳
王劭阳

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)

  • 从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)存储成本计算：单个索
  • 我们的AI人工智能，自动发布了一篇假新闻…… 数据断案 数据人的故事人工智能数据库sqloracle数据分析
    今天这个故事，还得从一个事故开始说起。前些日子，我们被XX公司投诉，说我们的资讯发布了关于他们公司授信额度的不实报道：告诉我们这篇资讯与他们公司最新公开披露的数据不一致，相关内容并不属实，可能对广大网友们造成严重误导，并对他们公司造成了严重负面影响……balabala一堆指责，并要求我们3小时内删除全部相关信息。然后，他们丢了2篇公告附件过来。我们对照着仔细一看，还真是我们搞错了：由于数据错误，“
  • Lua语言的计算机体系结构 凌嘉遥 包罗万象golang开发语言后端
    Lua语言的计算机体系结构引言Lua是一种轻量级、高效且可扩展的脚本语言，最早由巴西的一个小组开发。它的设计目标是为嵌入式系统提供一个简洁的语言，从而使开发者能够在不同的应用程序中方便地进行扩展和集成。尽管Lua本身是一种面向过程的语言，但它也支持面向对象编程、函数式编程等多种编程范式。因此，研究Lua的计算机体系结构，不仅能帮助我们理解Lua如何实现其功能，还能为其他编程语言的设计与实现提供参考
  • 精选AI大模型读物：《从ChatGPT到AIGC：智能创作与应用赋能》——探索智能时代的创作力量 AGI大模型老王 人工智能chatgptAIGCAI大模型大模型
    自2023年以来，AI聊天机器人ChatGPT火爆互联网，其颠覆性的使用体验重塑了人们对于AI的认知。而ChatGPT背后的技术―AIGC也引起了互联网圈的关注，打开了人们对AI应用的想象空间。本书从ChatGPT入手，以AIGC为中心，对AIGC的理论知识、应用场景、未来发展等内容进行了全面的梳理。首先，本书对AIGC的概念、技术构成、产业生态、市场现状等进行了讲解，以便读者对AIGC形成一个清
  • 02、数据结构与算法 - 基础：数组 - 吊打面试官 星星学霸 数据结构与算法-吊打面试官python开发语言java算法数据结构
    更多系列教程，每天更新更多教程关注：xxxueba.com星星学霸本篇博客我们介绍数据结构的鼻祖------数组，可以说数组几乎能表示一切的数据结构，在每一门编程语言中，数组都是重要的数据结构，当然每种语言对数组的实现和处理也不相同，但是本质是都是用来存放数据的的结构，这里我们以Java语言为例，来详细介绍Java语言中数组的用法。Java中数组的介绍在Java中，数组是用来存放同一种数据类型的集
  • 案例驱动的 IT 团队管理：创新与突破之路：第一章 重构 IT 团队管理：从传统到创新-2.1.2关键岗位胜任力模型设计 言析数智 案例驱动的IT团队管理：创新与突破之路IT项目管理关键岗位胜任力模型
    点击关注不迷路点击关注不迷路点击关注不迷路文章大纲第二章团队组建：从人才画像到生态构建-2.1.2关键岗位胜任力模型设计一、胜任力模型的核心理念与价值1.**传统选才vs胜任力驱动选才**2.**冰山模型：胜任力的分层结构**二、胜任力模型构建的六步法1.**战略对齐与岗位分析**2.**行为事件访谈（BEI）**3.**数据建模与验证**4.**模型分层与指标定义**5.**试点应用与迭代优化*
  • 深入解析两大AI模型的架构与功能 草莓屁屁我不吃 人工智能chatgpt
    在人工智能（AI）领域，自然语言处理（NLP）一直是研究的热点之一。随着技术的不断进步，我们见证了从简单的聊天机器人到复杂语言模型的演变。其中，Google的Gemini和OpenAI的ChatGPT作为两大代表性模型，各自在技术和应用上展现出了卓越的性能。本文将详细解析Gemini和ChatGPT的系统架构、功能特性及其背后的技术原理。Gemini模型详解技术背景与架构Gemini，顾名思义，意
  • 案例驱动的 IT 团队管理：创新与突破之路：第一章 重构 IT 团队管理：从传统到创新-1.1.1技术迭代加速与人才断层 言析数智 案例驱动的IT团队管理：创新与突破之路IT项目管理IT创新
    点击关注不迷路点击关注不迷路点击关注不迷路文章大纲案例驱动的IT团队管理：创新与突破之路第一章重构IT团队管理：从传统到创新-1.1.1技术迭代加速与人才断层1.技术迭代加速的现状与影响1.1技术迭代速度的`量化分析`2.人才断层的核心表现2.1供需失衡的数据对比2.2人才断层的具体表现3.传统管理模式的失效分析3.1经典管理理论的局限性3.2典型案例：某金融IT系统升级失败4.创新管理路径探索4
  • 国家网络安全事件应急预案 bubble87 web安全安全
    目录1总则1.1编制目的1.2编制依据1.3适用范围1.4事件分级1.5工作原则2组织机构与职责2.1领导机构与职责2.2办事机构与职责2.3各部门职责2.4各省（区、市）职责3监测与预警3.1预警分级3.2预警监测3.3预警研判和发布3.4预警响应3.5预警解除4应急处置4.1事件报告4.2应急响应4.3应急结束5调查与评估6预防工作6.1日常管理6.2演练6.3宣传6.4培训6.5重要活动期间
  • 纳米尺度仿真软件：Quantum Espresso_（20）.机器学习在QuantumEspresso中的应用 kkchenjj 分子动力学2机器学习人工智能模拟仿真仿真模拟分子动力学
    机器学习在QuantumEspresso中的应用在现代材料科学和纳米技术的研究中，机器学习（ML）技术已经成为一种强大的工具，用于加速和优化量子力学计算。QuantumEspresso是一个广泛使用的开源软件包，用于进行第一性原理计算，特别是在纳米尺度材料的模拟中。本节将介绍如何将机器学习技术应用于QuantumEspresso，以提高计算效率、预测材料性质和优化结构。1.机器学习与第一性原理计算
  • 深入探索Ajax技术与应用实践 Javen Fang
    本文还有配套的精品资源，点击获取简介：Ajax技术允许在不刷新整个页面的情况下进行网页内容的局部更新，大大提升了用户体验。文章详细解析了Ajax的核心组件和工作流程，并强调了其在Web开发中的重要性。此外，还探讨了Ajax的优点、应用场景以及在实际开发中需要注意的问题。通过学习Ajax，开发者可以设计出更加动态和高效的网页应用。1.Ajax技术概述和定义Ajax技术概述Ajax技术的核心在于其异步
  • 电机控制常见面试问题（十三） 小雀丝 电机控制电机嵌入式硬件
    文章目录一、直流电机与交流电机的基本工作原理二、永磁同步电机和异步电机区别三.PID控制器的原理及其在电机速度控制中的应用四.电机驱动电路设计的关键因素五.电机发热过高的有效原因以及处理办法六.常见电机过载保护方法及其工作原理七.电机振动的原因以及处理八.电机电流波形分析判断电机故障–一、直流电机与交流电机的基本工作原理直流电机中，直流发电机是电枢在原动机拖动下旋转，其导体切割主磁极固定磁场产生感
  • 如何减少跨团队交付摩擦？——基于 DevOps 与敏捷的最佳实践 网罗开发 实战实战源码devops运维
    网罗开发（小红书、快手、视频号同名）  大家好，我是展菲，目前在上市企业从事人工智能项目研发管理工作，平时热衷于分享各种编程领域的软硬技能知识以及前沿技术，包括iOS、前端、HarmonyOS、Java、Python等方向。在移动端开发、鸿蒙开发、物联网、嵌入式、云原生、开源等领域有深厚造诣。图书作者：《ESP32-C3物联网工程开发实战》图书作者：《SwiftUI入门，进阶与实战》超级个体：CO
  • FireRedASR：精准识别普通话、方言和歌曲歌词！小红书开源工业级自动语音识别模型 蚝油菜花 每日AI项目与应用实例语音识别人工智能人工智能开源
    ❤️如果你也关注AI的发展现状，且对AI应用开发感兴趣，我会每日分享大模型与AI领域的开源项目和应用，提供运行实例和实用教程，帮助你快速上手AI技术！微信公众号｜搜一搜：蚝油菜花大家好，我是蚝油菜花，今天跟大家分享一下FireRedASR这个小红书开源的工业级自动语音识别模型。快速阅读FireRedASR是小红书开源的工业级自动语音识别模型，支持普通话、中文方言和英语。该模型在普通话ASR基准测试
  • java实现卷积神经网络CNN（附带源码） Katie。 Java实战项目java
    Java实现卷积神经网络（CNN）项目详解目录项目概述1.1项目背景与意义1.2什么是卷积神经网络（CNN）1.3卷积神经网络的应用场景相关知识与理论基础2.1神经网络与深度学习概述2.2卷积操作与卷积层原理2.3激活函数与池化层2.4全连接层与损失函数2.5前向传播、反向传播与梯度下降项目需求与分析3.1项目目标3.2功能需求分析3.3性能与扩展性要求3.4异常处理与鲁棒性考虑系统设计与实现思路
  • Agora-Uniapp-SDK 使用指南 章瑗笛
    Agora-Uniapp-SDK使用指南Agora-Uniapp-SDK项目地址:https://gitcode.com/gh_mirrors/ag/Agora-Uniapp-SDK1.项目目录结构及介绍Agora-Uniapp-SDK是一个基于Uni-app与AgoraAndroid和iOS视频SDK实现的集成库，它专门设计用于简化在uni-app项目中集成Agora音视频功能的过程。以下是其主
  • 深度解析前端面试八股文：核心知识点与高效应对策略 赵大仁 前端面试职场和发展
    深度解析前端面试八股文：核心知识点与高效应对策略1.引言前端面试是每位开发者迈向职业进阶的重要环节，涉及HTML、CSS、JavaScript、性能优化、浏览器原理、网络、安全、框架（Vue/React）等核心知识点。本文不仅会覆盖前端面试的高频八股文，还会结合生动的案例，让你在面试时能够脱离死记硬背，从理解中突破！2.HTML&CSS高频考点2.1HTML语义化问题：什么是HTML语义化？为什么
  • 展望 AIGC 前景：通义万相 2.1 与蓝耘智算平台共筑 AI 生产力高地 accurater AIGC人工智能神经网络深度学习
    喜欢可以到主页订阅专栏引言人工智能生成内容（AIGC）技术正在重塑内容创作、影视制作、广告设计等行业的底层逻辑。作为该领域的革命性技术代表，通义万相2.1凭借其开源特性、多模态生成能力和技术突破，成为全球视频生成模型的标杆。而蓝耘智算平台则通过高性能算力支持与分布式架构优化，为AIGC技术的规模化应用提供了基础设施保障。两者的协同不仅推动了AI生产力的跃迁，更开启了从技术研发到商业落地的全链条创新
  • PHP与数据库连接常见问题及解决办法 奥顺互联_老张 php教程php数据库
    PHP与数据库连接常见问题及解决办法在现代Web开发中，PHP与数据库的连接是不可或缺的一部分。无论是构建动态网站、内容管理系统（CMS）还是电子商务平台，PHP与数据库的交互都是核心功能之一。然而，在实际开发过程中，开发者常常会遇到各种与数据库连接相关的问题。本文将探讨PHP与数据库连接中的常见问题，并提供相应的解决办法。1.数据库连接失败问题描述在PHP中，连接数据库时最常见的错误是无法连接到
  • Android中实现多线程的几种方式 Ever69 Android《葵花宝典》android
    目录1.基础线程（Thread）2.Handler与Looper3.AsyncTask（已废弃，仅作了解）4.ExecutorService（线程池）5.IntentService（已废弃，推荐WorkManager）6.Kotlin协程（Coroutines，现代推荐方案）7.HandlerThread对比总结最佳实践建议在Android中，实现多线程编程主要有以下几种方式，每种方式都有其适用场
  • 信号传输与通信：光纤通信中的信号处理_（15）.高级光信号处理技术 kkchenkx 信号处理技术仿真模拟信号处理网络数据库
    高级光信号处理技术1.光纤通信中的非线性效应及其补偿1.1光纤非线性效应的原理光纤通信系统中，非线性效应是限制系统性能的关键因素之一。非线性效应主要包括自相位调制（SPM）、交叉相位调制（XPM）、四波混频（FWM）和受激拉曼散射（SRS）等。这些效应在高功率、长距离传输中尤为显著，会导致信号的相位和频率失真，进而影响信号的传输质量。1.1.1自相位调制（SPM）自相位调制是指光波在光纤中传播时，
  • 信号传输与通信：光纤通信中的信号处理_（13）.光纤通信中的色散管理 kkchenkx 信号处理技术仿真模拟信号处理网络
    光纤通信中的色散管理色散的基本概念色散是光纤通信中的一个关键问题，它会导致信号在传输过程中发生失真。色散主要分为两类：模态色散和色度色散。模态色散模态色散主要发生在多模光纤中。多模光纤允许多个模式同时传播，但由于每个模式的传播速度不同，导致不同模式的光在光纤中传播的时间不同。这种时间差会导致信号的展宽，从而引起失真。色度色散色度色散主要发生在单模光纤中。色度色散是由于不同波长的光在光纤中的传播速度
  • Java中的参数传递机制：值传递与引用传递的真相 啊sen丶 java开发语言
    在Java编程中，参数传递机制是每个开发者都必须理解的基本概念之一。然而，关于Java的参数传递机制，常常存在一些误解。很多人会问：“Java是按值传递还是按引用传递？”本文将通过详细的解释和代码示例，帮助你彻底理解Java的参数传递机制。一、值传递与引用传递的基本概念（一）值传递（PassbyValue）值传递是指在调用方法时，将实际参数的值复制一份传递给方法。在方法内部对参数的修改不会影响到原
  • 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