Java多线程CompletableFuture使用

引言

一个接口可能需要调用N个其他服务的接口，这在项目开发中非常常见。如果是串行执行的话，接口的响应速度会很慢。考虑到这些接口之间有大部分都是无前后顺序关联的，可以并行执行。就比如说调用获取商品详情的时候，可以同时调用获取物流信息，通过并行执行多个任务的方式，接口的响应速度会得到大幅度优化。

在这里插入图片描述

对于存在前后顺序关系的接口调用，可以进行编排，如下所示
在这里插入图片描述

  • 获取用户信息之后，才能调用商品详情和物流信息接口。
  • 成功获取商品详情和物流信息之后，才能调用商品推荐接口。

对于Java程序来说，Java8 引入的CompletableFuture可以帮助我们做多个任务的编排，功能非常强大。

Future介绍

Future类是异步思想的典型运用，主要用在一些需要执行耗时任务的场景，避免程序一直原地等待耗时任务执行完成。执行效率太低。具体来说：当我们执行一个耗时的任务时，可以将这个耗时任务交给一个子线程去异步执行，同时，我们可以干点其他事情，不用等待耗时任务执行完成。等我们其他事情做完，再通过Future类获取耗时任务的执行结果。 这样一来，程序的执行效率就明显提高了。

这其实就是多线程中经典的Future模式。核心思想是异步调用，主要用在多线程的领域。

在Java中，Future类只是一个泛型接口，位于java.util.concurrent 包下，其中定义了 5 个方法，主要包括下面这 4 个功能：

  • 取消任务
  • 判断任务是否被取消
  • 判断任务是否已经执行完成
  • 获取任务执行结果
// V 代表了Future执行的任务返回值的类型
public interface Future<V> {
    // 取消任务执行
    // 成功取消返回 true，否则返回 false
    boolean cancel(boolean mayInterruptIfRunning);
    // 判断任务是否被取消
    boolean isCancelled();
    // 判断任务是否已经执行完成
    boolean isDone();
    // 获取任务执行结果
    V get() throws InterruptedException, ExecutionException;
    // 指定时间内没有返回计算结果就抛出 TimeOutException 异常
    V get(long timeout, TimeUnit unit)
     throws InterruptedException, ExecutionException, TimeoutExceptio
}

CompletableFuture介绍

Future在实际使用过程中存在一些局限性比如不支持异步任务的编排组合、获取计算结果的get()方法为阻塞调用。

Java8 引入了CompletableFuture类可以解决Future的这些缺陷。CompletableFuture除了提供更为好用和强大的Future特性之外，还提供了函数式编程、异步任务编排组合（可以将多个任务串联起来，组成一个完整的链式调用）等能力。

public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {
}

CompletableFuture同时实现了Future和CompletionStage接口。CompletionStage接口描述了一个异步计算的阶段，很多计算可以分成多个阶段或步骤。此时可以通过他将所有步骤组合起来，形成异步计算的流水线。

CompletionStage接口中的方法比较多，CompletableFuture的函数式能力就是这个接口赋予的，从这个接口的方法参数可以发现其大量使用了Java8 引入的函数式编程。

在这里插入图片描述

CompletableFuture常见操作

创建CompletableFuture

常见的常见CompletableFuture对象的方法如下：

  1. 通过new关键字
  2. 基于CompletableFuture自带的静态工厂方法：runAsync()、supplyAsync()。

new 关键字

代码示例

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

public class CompletableFutureExample {
    public static void main(String[] args) {
        // 创建一个CompletableFuture对象，初始值为null
        CompletableFuture<String> resultFuture = new CompletableFuture<>();
        // 模拟异步任务
        new Thread(() -> {
            // 这里模拟一个耗时操作
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 异步任务完成，设置结果到CompletableFuture中
            resultFuture.complete("Hello, CompletableFuture!");
        }).start();

        // 当异步任务完成时调用该方法
        resultFuture.thenAccept(result -> System.out.println("异步任务完成，结果为: " + result));
        // 等待异步任务完成并获取结果
        try {
            String result = resultFuture.get();
            System.out.println("获取到异步任务的结果: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

说明
通过new关键字创建CompletableFuture对象这种使用方式可以看作是将CompletableFuture当作Future来使用。可以把resultFuture当作是一部运算结果的载体。

 CompletableFuture<String> resultFuture = new CompletableFuture<>();

假设在某个时刻，我们得到了最终的结果，这时，我们可以调用complete()方法为其传入结果，这表示resultFuture已经计算完成。

 resultFuture.complete("Hello, CompletableFuture!");

也可以通过isDone()方法来检查是否已经完成。

public boolean isDone() {
    return result != null;
}

获取异步计算的结果也非常简单，调用get()方法即可。调用get()方法的线程会阻塞直到CompletableFuture完成计算。

String result = resultFuture.get();

静态工厂方法

这两个方法可以帮助我们封装计算逻辑

static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier);
// 使用自定义线程池(推荐)
static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor);
static CompletableFuture<Void> runAsync(Runnable runnable);
// 使用自定义线程池(推荐)
static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor);

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

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

使用示例：

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> System.out.println("hello!"));
future.get();// 输出 "hello!"
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "hello!");
assertEquals("hello!", future2.get());

处理异步计算结果

当我们获取到异步计算的结果之后，还可以对其进行进一步的处理，比较常用的方法如下：

  • thenApply() ： 当CompletableFuture完成时，将异步计算结果作为参数传递给指定的函数，并返回一个新的CompletableFuture作为异步结果。
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<String> resultFuture = future.thenApply(i -> "Result: " + i);
System.out.println(resultFuture.get()); // 输出 "Result: 10"
  • thenAccept()：当CompletableFuture完成时，将异步计算结果作为参数传递给指定的消费者函数，不返回任何结果。
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 10);
future.thenAccept(i -> System.out.println("Result: " + i));
  • thenRun()：当CompletableFuture完成时，执行指定的Runnable动作，不接受异步计算结果。
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 10);
future.thenRun(() -> System.out.println("Done!"));
  • whenComplete()：当CompletableFuture完成时，指定指定的动作，无论异步任务是否发生异常都会执行该操作。
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 10 / 0);
future.whenComplete((result, exception) -> {
    if (exception != null) {
        System.out.println("Exception occurred: " + exception.getMessage());
    } else {
        System.out.println("Result: " + result);
    }
});

1. thenApply()

方法接受一个Function实例，用它来处理结果。

// 沿用上一个任务的线程池
public <U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn) {
    return uniApplyStage(null, fn);
}

//使用默认的 ForkJoinPool 线程池（不推荐）
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn) {
    return uniApplyStage(defaultExecutor(), fn);
}
// 使用自定义线程池(推荐)
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn, Executor executor) {
    return uniApplyStage(screenExecutor(executor), fn);
}

使用示例如下：
实例一：

CompletableFuture<String> future = CompletableFuture.completedFuture("hello!")
        .thenApply(s -> s + "world!");
assertEquals("hello!world!", future.get());
// 这次调用将被忽略。
future.thenApply(s -> s + "nice!");
assertEquals("hello!world!", future.get());

实例二：还可以进行流式调用

CompletableFuture<String> future = CompletableFuture.completedFuture("hello!")
        .thenApply(s -> s + "world!").thenApply(s -> s + "nice!");
assertEquals("hello!world!nice!", future.get());

如果不需要从回调函数中获取返回结果，可以使用thenAccept()或者thenRun()。这两个方法的区别在于thenRun不能访问异步计算的结果。

2. thenAccpet()
方法的参数是 Consumer<? super T> action,将异步计算结果作为参数传递给指定的消费者函数。

public CompletableFuture<Void> thenAccept(Consumer<? super T> action) {
    return uniAcceptStage(null, action);
}

public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action) {
    return uniAcceptStage(defaultExecutor(), action);
}

public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action,
                                               Executor executor) {
    return uniAcceptStage(screenExecutor(executor), action);
}

3. thenRun()
方法参数是Runnable，不能访问异步计算的结果，只能在异步计算完成后，继续其他操作。

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

public CompletableFuture<Void> thenRunAsync(Runnable action) {
    return uniRunStage(defaultExecutor(), action);
}

public CompletableFuture<Void> thenRunAsync(Runnable action,
                                            Executor executor) {
    return uniRunStage(screenExecutor(executor), action);
}

4. whenComplete()
whenComplete() 的方法的参数是 BiConsumer<? super T, ? super Throwable> 。

public CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action) {
    return uniWhenCompleteStage(null, action);
}
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action) {
    return uniWhenCompleteStage(defaultExecutor(), action);
}
// 使用自定义线程池(推荐)
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action, 
Executor executor) {
    return uniWhenCompleteStage(screenExecutor(executor), action);
}

BiConsumer可以接受两个输入对象然后进行消费，BiConsumer<? super T, ? super Throwable>
第一个参数

？super T : 父类为CompletableFuture创建时使用泛型T 定义的返回结果类型。传入异步计算结果。
？super Throwable：父类为Throwable，即异步计算结果抛出异常时，该字段不为空。

处理异常

可以通过handle()方法来处理任务执行过程中可能出现的异常情况。

public <U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn) {
    return uniHandleStage(null, fn);
}

public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn) {
    return uniHandleStage(defaultExecutor(), fn);
}

public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, 
Executor executor) {
    return uniHandleStage(screenExecutor(executor), fn);
}

示例代码：

CompletableFuture<String> future= CompletableFuture.supplyAsync(() -> {
    if (true) {
        throw new RuntimeException("Computation error!");
    }
    return "hello!";
}).handle((res, ex) -> {
    // res 代表返回的结果
    // ex 的类型为 Throwable ，代表抛出的异常
    return res != null ? res : "world!";
});
assertEquals("world!", future.get());

还可以通过 exceptionally() 方法来处理异常情况。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (true) {
        throw new RuntimeException("Computation error!");
    }
    return "hello!";
}).exceptionally(ex -> {
    System.out.println(ex.toString());// CompletionException
    return "world!";
});
assertEquals("world!", future.get());

如果想让CompletableFuture结果就是异常的话，可以使用completeExceptionally()为其赋值。

CompletableFuture<String> completableFuture = new CompletableFuture<>();
// ...
completableFuture.completeExceptionally(
  new RuntimeException("Calculation failed!"));
// ...
completableFuture.get(); // ExecutionException

组合CompletableFuture

可以使用thenCompose() 按顺序链接两个completableFuture对象，实现异步的任务链。他的作用是将前一个任务的返回结果作为下一个任务的输入参数，从而形成一个依赖关系。

public <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn) {
    return uniComposeStage(null, fn);
}

public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn) {
    return uniComposeStage(defaultExecutor(), fn);
}

public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn,
    Executor executor) {
    return uniComposeStage(screenExecutor(executor), fn);
}

使用示例：

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "hello!")
        .thenCompose(s -> CompletableFuture.supplyAsync(() -> s + "world!"));
assertEquals("hello!world!", future.get());

在实际开发中，这个方法还是非常有用的，比如，task1和task2都是异步执行，但是task1必须执行完成后才能开始执行task2（task2依赖task1的执行结果）。
和thenCompose()类似的还有thenCombine()，他同样可以组合两个CompletableFuture对象。

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "hello!")
        .thenCombine(CompletableFuture.supplyAsync( () -> "world!"), (s1, s2) -> s1 + s2)
        .thenCompose(s -> CompletableFuture.supplyAsync(() -> s + "nice!"));
assertEquals("hello!world!nice!", completableFuture.get());

thenCompose()和thenCombine()有什么区别

  • thenCompose()可以链接两个completableFuture对象，并将前一个任务的结果作为下一个任务的参数，他们之间存在先后关系。
  • thenCombine() 会在两个任务都执行完成后，把两个任务的结果合并。两个任务是并行执行的。他们之间没有先后依赖关系。

除了thenCompose()、thenCombine() 之外，还有一些其他的组合completableFuture方法用于实现不同的效果，满足不同的业务需求。

例如，如果我们想要实现task1和task2中的任意一个任务后就可以执行task3的话，可以使用acceptEither().

public CompletableFuture<Void> acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action) {
    return orAcceptStage(null, other, action);
}

public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action) {
    return orAcceptStage(asyncPool, other, action);
}

示例程序：

CompletableFuture<String> task = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务1开始执行，当前时间：" + System.currentTimeMillis());
    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("任务1执行完毕，当前时间：" + System.currentTimeMillis());
    return "task1";
});

CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务2开始执行，当前时间：" + System.currentTimeMillis());
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("任务2执行完毕，当前时间：" + System.currentTimeMillis());
    return "task2";
});

task.acceptEitherAsync(task2, (res) -> {
    System.out.println("任务3开始执行，当前时间：" + System.currentTimeMillis());
    System.out.println("上一个任务的结果为：" + res);
});

// 增加一些延迟时间，确保异步任务有足够的时间完成
try {
    Thread.sleep(2000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

输出：

任务1开始执行，当前时间：1695088058520
任务2开始执行，当前时间：1695088058521
任务1执行完毕，当前时间：1695088059023
任务3开始执行，当前时间：1695088059023
上一个任务的结果为：task1
任务2执行完毕，当前时间：1695088059523

任务组合操作acceptEitherAsync()会在异步任务1和异步任务2中的任意一个完成时出发执行任务3.但需要注意，这个触发时机不确定。

并行运行多个CompletableFuture

可以通过CompletableFuture的allOf()这个静态方法来并行运行多个CompletableFuture。

实际项目中，我们经常需要并行运行多个互不相关的任务。这些任务之间没有依赖关系，可以互相独立的运行。

比如，我们需要读取处理6个文件，这6个任务都是没有执行顺序依赖的任务，但是我们需要返回给用户的时候将这几个文件的处理结果进行统计整理，这种情况我们可以使用并行运行多个CompletableFuture来处理。

示例如下：

CompletableFuture<Void> task1 = CompletableFuture.supplyAsync(()->{
    //自定义业务操作
  });
......
CompletableFuture<Void> task6 = CompletableFuture.supplyAsync(()->{
    //自定义业务操作
  });
......
 CompletableFuture<Void> headerFuture=CompletableFuture.allOf(task1,.....,task6);
  try {
    headerFuture.join();
  } catch (Exception ex) {
    ......
  }
System.out.println("all done. ");

经常和allOf()方法对比的是anyOf()方法。

allOf()方法会等到所有的CompletableFuture都运行完成之后在返回。调用join方法让task1。。。。task6都运行完之后在继续执行
anyOf方法不会等待所有的CompletableFuture都运行完成之后在返回，只要有一个执行完成即可。

CompletableFuture使用建议

使用自定义线程池

CompletableFuture默认使用ForkJoinPool.commonPool()作为执行器，这个线程池是全局共享的，可能会被其他任务占用，导致性能下降或者饥饿。建议使用自定义的线程池来执行CompletableFuture的异步任务，可以提高并发度和灵活性。

private ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 10,
        0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<Runnable>());

CompletableFuture.runAsync(() -> {
     //...
}, executor);

尽量避免使用get()

CompletableFuture的get()方法是阻塞的，尽量避免使用。如果必须使用的话，需要添加超时时间，否则可能会导致主线程一直等待，无法执行其他任务。

    CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
        try {
            Thread.sleep(10_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "Hello, world!";
    });

    // 获取异步任务的返回值，设置超时时间为 5 秒
    try {
        String result = future.get(5, TimeUnit.SECONDS);
        System.out.println(result);
    } catch (InterruptedException | ExecutionException | TimeoutException e) {
        // 处理异常
        e.printStackTrace();
    }
}

上面这段代码在调用get()时抛出TimeoutException，我们可以在异常处理中进行相应的操作，如取消任务、重试任务、记录日志等。

正确进行异常处理

使用 CompletableFuture的时候一定要以正确的方式进行异常处理，避免异常丢失或者出现不可控问题。

  • 使用whenComplete方法可以在任务完成时触发回调函数，并正确处理异常，而不是让异常被吞噬或丢失。
  • 使用exceptionally方法可以处理异常并重新抛出，以便异常能够传播到后续阶段，而不是让异常被忽略或者终止。
  • 使用handle方法可以处理正常的返回结果和异常，并返回一个新的结果，而不是让异常影响整体的逻辑。
  • 使用CompletableFuture.allOf方法可以组合多个CompletableFuture，并统一处理所有任务的异常，而不是让异常处理过于冗长或者重复。

合理组合多个异步任务

正确使用thenCompose()、thenCombine()、acceptFilter()、allOf()、anyOf()等方法来组合多个异步任务，以满足实际业务需求，提高程序执行效率。

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/701443.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

嵌入式单片机中项目在线仿真工具分享

嵌入式单片机中项目在线仿真工具分享

前段时间，无意间发现了一个不错的在线仿真工具（Wokwi），支持多种平台，支持市面上主流的开发板，比如：STM32、ESP32、Arduino、树莓派等。 还支持常见的传感器、显示器件（LCD、LED屏幕）等，还可以播放音乐、联网、逻辑分析仪等，关键还提供了很多实际项目的案例。 这款工…
阅读更多...
Offline ：Adversarially Trained Actor Critic for Offline Reinforcement Learning

Offline ：Adversarially Trained Actor Critic for Offline Reinforcement Learning

ICML 2022 paper code 基于Stackelberg游戏博弈形式&#xff0c;对抗的学习actor与critic Intro Method 将离线RL的Stackelberg博弈表述为一个双层优化问题&#xff0c;学习者策略π∈Π为领导者&#xff0c;批评家f∈F为跟随者: π ^ ∗ ∈ argmax ⁡ π ∈ I I L μ ( π…
阅读更多...
Pixi.js学习 （六）数组

Pixi.js学习 （六）数组

目录 前言 一、数组 1.1 定义数组 1.2 数组存取与删除 1.3 使用数组统一操作敌机 二、实战 例题一&#xff1a;使用数组统一操作敌机 例题一代码&#xff1a; 总结 前言 为了提高作者的代码编辑水品&#xff0c;作者在使用博客的时候使用的集成工具为 HBuilderX。 下文所有截…
阅读更多...
echarts学习：调色盘

echarts学习：调色盘

前言 在之前的几篇文章中&#xff0c;我试图复现下面的这张图表。 目前复现的效果如下&#xff1a; 今天我想要实现的效果是让y轴与对应的折线显示同样的颜色。 1.调色盘介绍 我早就听说echarts存在一个调色盘的概念&#xff0c;如今终于是好好的了解了一下。调色盘就是配置项…
阅读更多...
JAVA反编译工具-CFR(class单个反编译、JAR包整体反编译)

JAVA反编译工具-CFR(class单个反编译、JAR包整体反编译)

环境说明 1、win10 2、JAVA8&#xff08;环境变量要配置好&#xff09; 3、cfr版本&#xff1a;C:\Users(xx)当前用户\cfr-0.152.jar 4、命令行操作路径&#xff1a;C:\Users(xx)当前用户 5、示例反编译jar包&#xff1a;C:\Users(xx)当前用户\ruoyi-admin.jar CFR工具相关参…
阅读更多...
【Unity】加速Unity编辑器模式启动时间

【Unity】加速Unity编辑器模式启动时间

Unity每次Play之后都会Reload Script Assemblies&#xff08;重新加载脚本程序集&#xff09;。 如果我们没有使用很多Assem&#xff0c;则并不需要在播放前重新编译。 可以在设置中将此事的重新编译关闭。 在Edit > Project Settings > Editor 面板中 找到Enter Play…
阅读更多...
Linux项目自动化构建工具

Linux项目自动化构建工具

一.背景 会不会写makefile&#xff0c;从侧面说明了一个人是否具备完成大型工程的能力。 一个工程中的源文件不计其数&#xff0c;按照类型&#xff0c;功能&#xff0c;模块分别放在若干个目录中&#xff0c;makefile定义了一系列的规则来指定&#xff0c;哪些文件需要先编译…
阅读更多...
django学生信息管理系统-计算机毕业设计源码95780

django学生信息管理系统-计算机毕业设计源码95780

摘要 从20年代开始&#xff0c;计算机疯狂的出现在人们的生活以及工作当中&#xff0c;成为人们生活、工作的好帮手&#xff0c;计算机深入到每家每户当中&#xff0c;网络办公&#xff0c;网络教学更是替换了传统手工记录管理的方式&#xff0c;使用计算机办公可以不必局限于固…
阅读更多...
【SSM】医疗健康平台-项目开发准备

【SSM】医疗健康平台-项目开发准备

知识目标 了解架构&#xff0c;能够说出常用的架构及其优缺点 熟悉项目的技术栈&#xff0c;能够说出每个技术栈的用途 了解项目的功能结构&#xff0c;能够说出医疗健康项目的功能组成 掌握医疗健康项目的环境搭建&#xff0c;能够根据系统模块的划分搭建医疗健康项目中的父…
阅读更多...
五、LVS原理

五、LVS原理

目录 5.1 LVS 相关原理 5.1.1 LVS集群的体系结构以及特点 5.1.1.1 LVS简介 5.1.1.2 LVS体系结构 5.1.1.3 LVS相关术语 5.1.1.4 LVS工作模式 5.1.1.5 LVS调度算法 5.1.2 LVS-DR集群介绍 5.1.2.1 LVS-DR模式工作原理 5.1.2.2 LVS-DR模式应用特点 5.1.2.3 LVS-DR模式ARP抑制 5.1…
阅读更多...
解决layui框架自带的excel导出长数据变科学计数法（使用\t和不使用\t的方法）

解决layui框架自带的excel导出长数据变科学计数法（使用\t和不使用\t的方法）

前言：项目中需要导出excel时，如果是大项目、要求高，当然使用第三方插件，或者后台导出是必要的，但是如果是一些小型项目，并且对导出excel样式要求不是很严格的，而且前端框架用的是layui的，layui框架自带的excel导出就成了我们最方便快捷的选择，但是在导出数据时会遇到一…
阅读更多...
[CUDA编程] cuda graph优化心得

[CUDA编程] cuda graph优化心得

CUDA Graph 1. cuda graph的使用场景 cuda graph在一个kernel要多次执行&#xff0c;且每次只更改kernel 参数或者不更改参数时使用效果更加&#xff1b;但是如果将graph替换已有的kernel组合&#xff0c;且没有重复执行&#xff0c;感觉效率不是很高反而低于原始的kernel调用…
阅读更多...
2024年6月份实时获取地图边界数据方法，省市区县街道多级联动【附实时geoJson数据下载】

2024年6月份实时获取地图边界数据方法，省市区县街道多级联动【附实时geoJson数据下载】

首先&#xff0c;来看下效果图 在线体验地址&#xff1a;https://geojson.hxkj.vip&#xff0c;并提供实时geoJson数据文件下载 可下载的数据包含省级geojson行政边界数据、市级geojson行政边界数据、区/县级geojson行政边界数据、省市区县街道行政编码四级联动数据&#xff0…
阅读更多...
根据mooc 数据库旧代码 实现剥离数据库链接单独成类，并进行测试

根据mooc 数据库旧代码 实现剥离数据库链接单独成类，并进行测试

数据源详情链接&#xff0c;SQLserver 2019 代码复制粘贴可产生数据 数据库JDBC 查询sqlserver 2019 利用模板实现输入查询-CSDN博客 效果如下 剥离的链接模块 Slinkv2.java package SQLadd;import java.sql.Connection; import java.sql.DriverManager; import java.sql.Re…
阅读更多...
在ensp上配置动态路由协议实验设计

在ensp上配置动态路由协议实验设计

动态路由协议是用来在网络中自动更新路由信息的一种技术&#xff0c;它可以让网络设备&#xff08;如路由器&#xff09;根据当前网络的状态调整数据的传输路径。这种协议特别适用于大型复杂的网络环境&#xff0c;可以有效地处理网络配置的变化&#xff0c;如链接的添加、删除…
阅读更多...
flutter报错You are currently using Java 1.8

flutter报错You are currently using Java 1.8

flutter报错Could not run phased build action using connection to Gradle distribution ‘https://services.gradle.org/distributions/gradle-7.6.3-all.zip’.\r\norg.gradle.api.ProjectConfigurationException: A problem occurred configuring root project ‘android’…
阅读更多...
Android RelativeLayout Rtl布局下的bug：paddingStart会同时作用于左右内边距

Android RelativeLayout Rtl布局下的bug：paddingStart会同时作用于左右内边距

问题现象 如上图&#xff0c;只是设置了paddingStart&#xff0c;在RTL布局下&#xff0c;左右都产生了10dp的间距。其他布局如LinearLayout&#xff0c;FrameLayout则没有这个问题。 private void positionAtEdge(View child, LayoutParams params, int myWidth) {if (isLayou…
阅读更多...
问题：一般在管理工作复杂、面广且管理分工比较细致的单位，常采用()组织形式。 #媒体#媒体

问题：一般在管理工作复杂、面广且管理分工比较细致的单位，常采用()组织形式。 #媒体#媒体

问题&#xff1a;一般在管理工作复杂、面广且管理分工比较细致的单位&#xff0c;常采用()组织形式。 A&#xff0e;直线式 B&#xff0e;职能式 C&#xff0e;矩阵式 D&#xff0e;团队式 参考答案如图所示
阅读更多...
使用易备数据备份软件，简单快速地备份 Oracle 数据库

使用易备数据备份软件，简单快速地备份 Oracle 数据库

易备数据备份软件能够以简单高效的方式&#xff0c;实现对 Oracle 数据库的保护。 易备数据备份软件数据库备份功能的关键特性 自动保护网站数据库及应用程序实时备份&#xff0c;不需要任何中断或数据库锁定基于日期和时间的备份任务计划可恢复到一个已存在的数据库或创建一…
阅读更多...
Web前端大作业：基于html+css+js的仿淘宝首页前端项目（内附源码）

Web前端大作业：基于html+css+js的仿淘宝首页前端项目（内附源码）

文章目录 一、项目介绍二、项目展示三、源码展示四、源码获取 一、项目介绍 这个项目是一个Web前端大作业,目的是让学生们通过实践仿设计淘宝官网的前端页面,来全面锻炼他们的HTML、CSS和JavaScript编程能力,以及产品需求分析、界面设计、交互设计等软实力。 淘宝作为国内最大…
阅读更多...
最新文章

Copyright @ 2022~2023