CompletableFuture——异步编程艺术

news2025/1/11 10:13:23

目录

1、CompletableFuture是什么？

2、CompletableFuture和Future、CompletionStage的关系？

3、CompletableFuture常用方法

3.1、 创建 CompletableFuture 实例

3.2、完成时触发thenApply、thenAccept、thenRun

3.3、组合多个 CompletableFuture

3.4、异常处理

3.5、其他方法

4、使用CompletableFuture 实现做肉丝面小案例

1、CompletableFuture是什么？

CompletableFuture是Java 8中引入的一个异步编程工具类，用于进行非阻塞的异步编程。它是Future接口的扩展，提供了更灵活、更强大的功能。

CompletableFuture可以用于处理异步操作，例如网络请求、数据库查询等。与传统的线程和回调方法相比，CompletableFuture提供了更简洁和方便的编程模型。

使用CompletableFuture的主要步骤如下：

  1. 创建一个CompletableFuture对象，可以通过CompletableFuture类的静态方法来创建，如CompletableFuture.supplyAsync()和CompletableFuture.runAsync()。
  2. 调用CompletableFuture对象的方法来定义异步操作的执行逻辑。可以使用thenApply()、thenAccept()和thenRun()等方法来对结果进行处理，或者使用whenComplete()和handle()等方法来处理异常情况。
  3. 使用CompletableFuture对象的get()方法来获取异步操作的结果，或者使用join()方法来等待异步操作的完成。

CompletableFuture还提供了一些其他功能，如组合多个CompletableFuture对象、并行执行异步任务、处理超时等。通过这些功能，可以更灵活地处理复杂的异步编程需求。

总之，CompletableFuture是一个功能强大的异步编程工具类，提供了简洁、方便和灵活的编程模型，可以帮助开发者更好地处理异步操作。

2、CompletableFuture和Future、CompletionStage的关系？

36d16b0a424e482ebf72c0a0f5b05e7d.png

CompletableFuture 是 Future 接口的一个实现类，并且也实现了 CompletionStage 接口。

Future 接口代表一个异步计算的结果，可以通过 get() 方法来获取计算结果。但是 Future 接口中的方法较为有限，只能判断计算是否完成、取消计算和获取计算结果（阻塞等待或者超时等待）等操作。

CompletableFuture 类提供了更多的操作方法，可以更方便地处理异步计算的结果。我们可以对计算结果执行一系列的操作，比如转换、组合、异常处理等。它还提供了一些便捷的静态方法，可以将同步方法转换为异步方法，并且可以指定线程池或者执行器来执行异步操作。

CompletionStage 接口是 CompletableFuture 的父接口，它定义了一些组合操作的方法，并且可以与 CompletableFuture 进行链式调用。CompletableFuture 实现了 CompletionStage 接口，所以 可以使用 CompletionStage 接口中的方法。

综上所述，可以得出一下结论：

（1）CompletableFuture 是对 Future 的增强，并且也是 CompletionStage 的实现类。

（2）CompletableFuture 提供了更多的操作方法和扩展功能，可以更灵活地处理异步计算的结果。

（3）CompletionStage 接口则提供了一些组合操作的方法，可以方便地对异步计算结果进行串行或并行处理。

3、CompletableFuture常用方法

3.1、 创建 CompletableFuture 实例

static CompletableFuture<Void> completedFuture(U value)
static CompletableFuture<Void> runAsync(Runnable runnable)
static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

（1）CompletableFuture.completedFuture 

方法用来创建一个已经完成的CompletableFuture对象。这个对象的结果是事先指定好的一个值或者异常。

这个方法有一个参数，可以是任意的类型，表示这个CompletableFuture对象的结果。返回值是一个已经完成的CompletableFuture对象。

CompletableFuture<Void> completedFuture = CompletableFuture.completedFuture(null);

（2）runAsync

方法接收一个Runnable参数，表示执行无返回值的异步任务。它返回一个CompletableFuture<Void>对象。

CompletableFuture<Void> runAsyncFuture = CompletableFuture.runAsync(() -> System.out.println("Run async"));

（3）supplyAsync

方法接收一个Supplier<T>参数，表示执行有返回值的异步任务。它返回一个CompletableFuture<T>对象。

CompletableFuture<String> supplyAsyncFuture = CompletableFuture.supplyAsync(() -> "Supply async");

runAsync和supplyAsync都是CompletableFuture类的静态方法，用于执行异步任务。

区别在于方法的参数和返回值类型不同。runAsync执行无返回值的异步任务，supplyAsync执行有返回值的异步任务，并将结果包装在CompletableFuture对象中返回。

3.2、完成时触发thenApply、thenAccept、thenRun

<U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn)
<U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn)
CompletableFuture<Void> thenAccept(Consumer<? super T> action)
CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action)
CompletableFuture<Void> thenRun(Runnable action)
CompletableFuture<Void> thenRunAsync(Runnable action)

（1）thenApply(Function<? super T,? extends U> fn)
这个方法在 CompletableFuture 完成后，将使用该 CompletableFuture 的结果作为输入，执行给定的 Function。这个 Function 接受一个类型为 T 的参数并返回一个类型为 U 的结果。返回一个新的 CompletableFuture<U>，它将在 Function 执行完毕后完成。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello").thenApply(String::length);

（2）thenApplyAsync(Function<? super T,? extends U> fn)
与 thenApply 类似，但 thenApplyAsync 会异步地执行给定的 Function。这意味着它将在一个新线程中执行 Function，而不是在完成原始 CompletableFuture 的同一个线程中。

（3）thenAccept(Consumer<? super T> action)
这个方法在 CompletableFuture 完成后，将使用该 CompletableFuture 的结果作为输入，执行给定的 Consumer。Consumer 接受一个类型为 T 的参数并执行一些操作，但不会返回任何结果。返回一个新的 CompletableFuture<Void>。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello").thenAccept(System.out::println);

（4）thenAcceptAsync(Consumer<? super T> action)
与 thenAccept 类似，但 thenAcceptAsync 会异步地执行给定的 Function。这意味着它将在一个新线程中执行 Function。

（5）thenRun(Runnable action)
这个方法在 CompletableFuture 完成后执行给定的 Runnable。这个 Runnable 不接受任何参数，也不返回任何结果。返回一个新的 CompletableFuture<Void>。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<Void> futureRun = future.thenRun(() -> System.out.println("Action completed"));

（6）thenRunAsync(Runnable action)
与 thenRun 类似，但 thenRunAsync 会异步地执行给定的 Runnable。这意味着它将在一个新线程中执行 Runnable。

区别：

  1. thenApply 与 thenApplyAsync 的区别在于执行 Function 的线程。thenApply 通常在完成原始 CompletableFuture 的同一个线程中执行，而 thenApplyAsync 总是在一个新线程中执行。
  2. thenAccept 与 thenAcceptAsync，以及 thenRun 与 thenRunAsync 的区别同理。
  3. thenApply、thenAccept 和 thenRun 是同步操作，意味着它们在当前线程上执行，除非前一个阶段是异步完成的。
  4. thenApplyAsync、thenAcceptAsync 和 thenRunAsync 是异步操作，意味着它们会在不同的线程上执行，通常是 ForkJoinPool.commonPool() 中的线程，或者可以通过提供一个自定义的 Executor 来指定。

3.3、组合多个 CompletableFuture

static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)
static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)

（1）allOf(CompletableFuture<?>... cfs)

该方法接收一个 CompletableFuture 数组，并返回一个新的 CompletableFuture<Void> 对象。这个方法会等待所有的 CompletableFuture 对象都执行完成，然后返回一个新的 CompletableFuture，它会在所有的 CompletableFuture 对象都执行完成后完成。如果任意一个 CompletableFuture 对象抛出异常，那么它会将异常传递给返回的 CompletableFuture 对象。

例如，假设有两个 CompletableFuture 对象 cf1 和 cf2，我们可以使用 allOf 方法等待它们都执行完成：

CompletableFuture<Void> allFutures = CompletableFuture.allOf(cf1, cf2);

（2）anyOf(CompletableFuture<?>... cfs)

该方法与 allOf 方法类似，但是它会等待任意一个 CompletableFuture 对象执行完成，然后返回一个新的 CompletableFuture<Object> 对象。如果其中任意一个 CompletableFuture 对象完成时有返回值，那么它将使用第一个完成的 CompletableFuture 的返回值作为返回值传递给返回的 CompletableFuture 对象。

CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(cf1, cf2);

总结：

这两个方法都是非阻塞的，即它们会立即返回一个 CompletableFuture 对象，不会等待 CompletableFuture 对象的执行完成。可以使用 thenApply、thenAccept 或者 thenRun 等方法来注册回调函数，以处理 CompletableFuture 的结果。 

3.4、异常处理

<U> CompletableFuture<U> exceptionally(Function<Throwable, ? extends U> fn)
<U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn)

（1）CompletableFuture<U> exceptionally(Function<Throwable, ? extends U> fn)

该方法可以用来处理异常情况。它接受一个Function参数，该参数是一个异常处理函数，用于处理出现的异常。如果CompletableFuture中发生了异常，那么这个异常会被传递给exceptionally方法，并由该方法的参数函数进行处理。处理完成后，exceptionally方法会返回一个新的CompletableFuture对象，该对象的结果是由异常处理函数的返回值决定。如果原始的CompletableFuture没有发生异常（即正常完成），那么exceptionally方法会返回一个与原始CompletableFuture相同的CompletableFuture对象。

（2）CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn)

该方法也可以用于处理异常情况。它接受一个BiFunction参数，该参数是一个处理函数，用于处理正常结果或异常。如果CompletableFuture正常完成，那么handle方法会将结果和异常值作为参数传递给处理函数。处理函数的返回值将被用作新的CompletableFuture的结果。如果CompletableFuture发生异常，那么handle方法会将异常和null作为参数传递给处理函数。处理函数的返回值也将被用作新的CompletableFuture的结果。

public class CompletableFutureDemo {
    public static void main(String[] args) {
        // 创建CompletableFuture
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 模拟抛出异常
            throw new RuntimeException("Exception occurred");
        });

        // 使用exceptionally处理异常
        CompletableFuture<String> exceptionHandledFuture = future.exceptionally(ex -> {
            return "Exception handled: " + ex.getMessage();
        });

        // 使用handle处理结果或异常
        CompletableFuture<String> resultFuture = future.handle((res, ex) -> {
            if (ex != null) {
                return "Exception handled: " + ex.getMessage();
            } else {
                return res;
            }
        });

        // 打印结果
        System.out.println(exceptionHandledFuture.join());
        System.out.println(resultFuture.join());
    }
}

总结起来，exceptionally方法和handle方法都是用于处理CompletableFuture发生的异常情况。它们提供了一种方式来处理异常并返回一个新的CompletableFuture对象，使得我们能够在异步操作完成后进行进一步的处理。

3.5、其他方法

<U> CompletableFuture<U> newIncompleteFuture()
boolean complete(T value)
boolean completeExceptionally(Throwable ex)
T getNow(T valueIfAbsent)
T join()
boolean isDone()
boolean isCancelled()
boolean cancel(boolean mayInterruptIfRunning)

（1）<U> CompletableFuture<U> newIncompleteFuture()

这个方法返回一个新的 CompletableFuture，它与当前实例具有相同的特征（例如，异步执行的特性），但是没有完成的值或异常。通常用于创建自定义的 CompletableFuture 实现或扩展。

CompletableFuture<String> future = new CompletableFuture<>();
CompletableFuture<String> newFuture = future.newIncompleteFuture();

（2）boolean complete(T value)

这个方法尝试将给定的值设置为 CompletableFuture 的结果。如果 CompletableFuture 已经完成，则返回 false；否则，它会被设置为给定的值，并返回 true。

CompletableFuture<String> future = new CompletableFuture<>();
boolean completed = future.complete("Completed value");
System.out.println("Future completed: " + completed); // 输出 true

（3）boolean completeExceptionally(Throwable ex)

这个方法尝试将给定的异常设置为 CompletableFuture 的异常结果。如果 CompletableFuture 已经完成，则返回 false；否则，它会被设置为给定的异常，并返回 true。

CompletableFuture<String> future = new CompletableFuture<>();
boolean completedExceptionally = future.completeExceptionally(new Exception("Error"));
System.out.println("Future completed exceptionally: " + completedExceptionally); // 输出 true

（4）T getNow(T valueIfAbsent)

这个方法返回 CompletableFuture 的当前值，如果没有完成，则返回给定的默认值 valueIfAbsent。

CompletableFuture<String> future = CompletableFuture.completedFuture("Hello");
String value = future.getNow("Default");
System.out.println(value); // 输出 Hello

CompletableFuture<String> futureNotCompleted = new CompletableFuture<>();
String defaultValue = futureNotCompleted.getNow("Default");
System.out.println(defaultValue); // 输出 Default

（5）T join()

这个方法与 getNow 类似，但它会阻塞当前线程直到 CompletableFuture 完成，然后返回结果。如果 CompletableFuture 已经完成，它将立即返回结果。

CompletableFuture<String> future = CompletableFuture.completedFuture("Hello");
String value = future.join();
System.out.println(value); // 输出 Hello

（6）boolean isDone()

这个方法返回 CompletableFuture 是否已经完成。完成可能是正常完成，也可能是由于异常。

CompletableFuture<String> future = new CompletableFuture<>();
System.out.println("Future is done: " + future.isDone()); // 输出 false

future.complete("Completed");
System.out.println("Future is done: " + future.isDone()); // 输出 true

（7）boolean isCancelled()

这个方法返回 CompletableFuture 是否已经被取消。

CompletableFuture<String> future = new CompletableFuture<>();
System.out.println("Future is cancelled: " + future.isCancelled()); // 输出 false

boolean cancelled = future.cancel(true);
System.out.println("Future is cancelled: " + future.isCancelled()); // 输出 true

（8）boolean cancel(boolean mayInterruptIfRunning)

这个方法尝试取消 CompletableFuture 的执行。如果 CompletableFuture 已经完成，则返回 false。如果 mayInterruptIfRunning 为 true，并且 CompletableFuture 正在运行，那么它将被中断。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    return "Result";
});

boolean cancelled = future.cancel(true);
System.out.println("Future cancelled: " + cancelled); // 输出 true

4、使用CompletableFuture 实现做肉丝面小案例

现在为了好理解并发编程的思想，这里我准备了一个贴合实际的小案例，就是做一碗肉丝面，我们先梳理一下做面的步骤过程，大致是一下几个步骤

1、备菜（切肉丝、切葱姜蒜、调味料、洗青菜、面条） （5分钟）


2、炒菜（下入肉丝、葱姜蒜翻炒、调味料调味） （2分钟）


3、煮开水 （10分钟）


4、下面条（煮3分钟）


5、下青菜再煮一会（1分钟）


6、完成

如果按照同步执行的话，就是代码依次从上往下执行，总共需要21分钟的时间，那么我们通过并发思想来节省一下时间。我们思考一下，备菜和煮开水是不是可以一起执行，因为我可以两个一起执行，这样是不是就可以节省时间了。具体实现参考下面代码

import java.util.concurrent.*;

public class CompletableFutureDemo {
    public static void main(String[] args) {
        // 创建自定义线程池
        int corePoolSize = 2; // 核心线程数
        int maximumPoolSize = 4; // 最大线程数
        long keepAliveTime = 60; // 非核心线程空闲存活时间
        TimeUnit unit = TimeUnit.SECONDS; // 时间单位
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(); // 阻塞队列
        ThreadFactory threadFactory = Executors.defaultThreadFactory(); // 线程工厂
        RejectedExecutionHandler handler = new ThreadPoolExecutor.CallerRunsPolicy(); // 拒绝策略

        ThreadPoolExecutor customThreadPool = new ThreadPoolExecutor(
                corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                unit,
                workQueue,
                threadFactory,
                handler
        );
        // 步骤1：备菜
        long startTime = System.currentTimeMillis();
        CompletableFuture<Void> prepareIngredients = CompletableFuture.runAsync(() -> {
            System.out.println("开始备菜...");
            // 模拟切肉丝、切葱姜蒜、准备调味料、洗青菜、面条
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("备菜完成。");
        },customThreadPool);

        // 步骤2：炒菜  使用thenRunAsync,等待步骤1执行结束再执行炒菜步骤
        CompletableFuture<Void> stirFry = prepareIngredients.thenRunAsync(() -> {
            System.out.println("开始炒菜...");
            // 模拟下入肉丝、葱姜蒜翻炒、调味料调味
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("炒菜完成。");
        },customThreadPool);

        // 步骤3：煮开水 可以直接使用runAsync，与步骤1备菜并行执行
        CompletableFuture<Void> boilWater = CompletableFuture.runAsync(() -> {
            System.out.println("开始煮开水...");
            // 模拟煮开水的过程
            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("水开了。");
        },customThreadPool);

        // 步骤4：下面条  使用allOf  等待步骤2、步骤3执行结束再执行
        CompletableFuture<Void> cookNoodles = CompletableFuture.allOf(stirFry, boilWater).thenRunAsync(() -> {
            System.out.println("下面条...");
            // 模拟煮面条的过程
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("面条煮熟了。");
        },customThreadPool);

        // 步骤5：下青菜再煮   等待步骤4结束执行
        CompletableFuture<Void> cookVegetables = cookNoodles.thenRunAsync(() -> {
            System.out.println("下青菜...");
            // 模拟下青菜的过程
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("青菜煮熟了。");
            System.out.println("完成烹饪，可以享用了！");
        },customThreadPool);
        // 等待所有步骤完成
        try {
            cookVegetables.get();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }finally {
            // 关闭线程池
            customThreadPool.shutdown();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("共消耗了：" + (endTime - startTime) / 1000 + "秒");
    }
}

可以看到，通过异步执行，14分钟（贴合实际，换算为分钟）就完成了肉丝面的制作，节省了7分钟的时间，效率提升了33%。

感谢您的阅读，制作不易，喜欢这篇文章的小伙伴们点赞关注支持一下吧。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C语言中的栈

C语言中的栈

一、栈的定义&#xff1a; 就是只能表的一端操作的顺序表或链表&#xff0c;允许操作的那一端成为栈顶元素&#xff0c;与之相对应的另一端称为栈底元素。 我们向栈里存入元素称为压栈&#xff0c;即最先放入的元素存放在栈底&#xff0c;最后放入的元素存放在栈顶。 我们将…
阅读更多...
怿星科技与您相约——2024 Testing Expo

怿星科技与您相约——2024 Testing Expo

汽车测试及质量监控博览会(中国)Testing Expo China-Automotive 怿星科技展位路线 届时欢迎莅临2057号展台&#xff01;
阅读更多...
OpenCV图像滤波(16)应用分离式滤波器函数sepFilter2D()的使用

OpenCV图像滤波(16)应用分离式滤波器函数sepFilter2D()的使用

操作系统&#xff1a;ubuntu22.04 OpenCV版本&#xff1a;OpenCV4.9 IDE:Visual Studio Code 编程语言&#xff1a;C11 算法描述 对图像应用分离式线性滤波器。 该函数对图像应用分离式线性滤波器。首先&#xff0c;src 的每一行都用 1D 内核 kernelX 进行滤波。然后&#x…
阅读更多...
爬虫 Web Js 逆向：RPC 远程调用获取加密参数（1）WebSocket 协议介绍

爬虫 Web Js 逆向：RPC 远程调用获取加密参数（1）WebSocket 协议介绍

RPC (Remote Procedure Call) 是远程调用的意思。 在 Js 逆向时&#xff0c;本地可以和浏览器以服务端和客户端的形式通过 WebSocket 协议进行 RPC 通信&#xff0c;这样可以直接调用浏览器中的一些函数方法&#xff0c;不必去在意函数具体的执行逻辑&#xff0c;可以省去大量…
阅读更多...
计算机网络面试题汇总

计算机网络面试题汇总

文章目录 计算机网络基础计算机网络体系结构(网络分层模型)OSI 七层模型是什么？每一层的作用是什么？TCP/IP 四层模型是什么？每一层的作用是什么？五层体系结构以及对应的协议为什么网络要分层，分层的好处？常见网络协议有哪些，每一层常见协议有哪些？应用层有哪些常见的协…
阅读更多...
【网编】——tcp编程

【网编】——tcp编程

tcp流程 服务器 头文件&#xff1a; #include <sys/types.h> /* See NOTES */ #include <sys/socket.h> #include <errno.h> #include<stdio.h> #include <netinet/in.h> #include <netinet/ip.h> /* superset of previous */ #…
阅读更多...
链接Mysql 报错connection errors； unblock with ‘mysqladmin flush-hosts‘错误的解决方法！亲测有效！

链接Mysql 报错connection errors； unblock with ‘mysqladmin flush-hosts‘错误的解决方法！亲测有效！

文章目录 前言一、使用 mysqladmin flush-hosts 命令解锁 IP 地址二、增加 max_connect_errors 参数三、检查连接错误的原因 前言 今天正常的对各大的测试服进行重启的时候发现每台服务器都启动失败&#xff01;查看日志发现每台服务器都报一下的错误 java.sql.SQLException:…
阅读更多...
分布式光伏管理系统具有什么功能？有推荐吗？

分布式光伏管理系统具有什么功能？有推荐吗？

1、项目进度管理 分布式光伏管理系统能够全面管理项目的进度&#xff0c;从初步沟通、收资踏勘、设计、施工到并网发电的全流程。系统通过可视化的项目进度管理工具&#xff0c;展示每一步的完成情况&#xff0c;包括员工跟进记录、关键节点时间等&#xff0c;帮助管理者从宏观…
阅读更多...
windows下php安装kafka

windows下php安装kafka

下载zookeeper Kafka 依赖 Zookeeper 进行分布式协调&#xff0c;所以需要下载Zookeeper &#xff0c;当然你也可以使用kafka包里自带的一个默认配置的 Zookeeper。这里我们单独下载一个 访问Zookeeper官方下载页面在页面中找到最新的稳定版本&#xff0c;点击相应的下载链接…
阅读更多...
Datawhale X 魔搭 AI夏令营第四期-魔搭生图task2学习笔记

Datawhale X 魔搭 AI夏令营第四期-魔搭生图task2学习笔记

精读代码 1.环境安装 !pip install simple-aesthetics-predictor!pip install -v -e data-juicer!pip uninstall pytorch-lightning -y !pip install peft lightning pandas torchvision!pip install -e DiffSynth-Studio 开始要先把代码中需要使用到的包、库用pip命令安装。…
阅读更多...
Fomepay和Fomecard是不是跑路了？

Fomepay和Fomecard是不是跑路了？

最近几天&#xff0c;fomepay跑路的消息&#xff0c;很多人知道了&#xff0c;fomepay客服繁忙&#xff0c;也无法提现。更多的是&#xff0c;很多人刚充值&#xff0c;才看到跑路的消息&#xff0c;实在惨啊&#xff01; 而现在&#xff0c;如果之前没有登录过fomepay的话&…
阅读更多...
安卓TV入门项目

安卓TV入门项目

android studio创建tv项目 下载android studio点此下载 配置环境变量&#xff1a; d盘新增Android文件夹&#xff0c;创建android-avd和android-sdk文件夹 环境变量名称&#xff1a;ANDROID_HOME 环境变量值&#xff1a;D:\Android\android-sdk 环境变量名称&#xff1a;ANDRO…
阅读更多...
深入理解 Spring 三级缓存：解决单例 Bean 循环依赖的利器

深入理解 Spring 三级缓存：解决单例 Bean 循环依赖的利器

目录 一、什么是循环依赖&#xff1f; 二、关于传说中的三级缓存 1.基本概念&#xff1a; 2.三级缓存是哪三级&#xff1f; 3.【举个例子】那三级缓存是怎么解决上述代码例子中的A、B互相依赖呢&#xff1f; 详细过程&#xff1a;&#xff08;理解用&#xff09; 简约版…
阅读更多...
【专题】2024年7月人工智能AI行业报告合集汇总PDF分享（附原数据表）

【专题】2024年7月人工智能AI行业报告合集汇总PDF分享（附原数据表）

原文链接:https://tecdat.cn/?p37350 随着人工智能技术的飞速发展&#xff0c;AI已经成为当今时代的重要驱动力。本报告将聚焦于人工智能AI行业的最新动态&#xff0c;涵盖客户服务、体验营销、资产管理以及国产AI大模型应用等多个领域。通过深入研究和分析&#xff0c;我们…
阅读更多...
【Python学习-UI界面】PyQt5 小部件5-QCheckBox

【Python学习-UI界面】PyQt5 小部件5-QCheckBox

样式如下: 当将QCheckBox对象添加到父窗口时&#xff0c;文本标签之前会出现一个矩形框。 和QRadioButton一样&#xff0c;它也是一个可选择的按钮。 它通常用于用户被要求选择一个或多个可用选项的场景。 不同于单选按钮&#xff0c;复选框默认情况下不是互斥的。 为了限制…
阅读更多...
Golang 与 Java：编程语言比较及如何选择

Golang 与 Java：编程语言比较及如何选择

Golang 与 Java&#xff1a;哪种语言更好&#xff1f;我们的详细比较指南涵盖了语法、性能和流行度方面的主要差异&#xff0c;以帮助您做出决定。 在规划项目时&#xff0c;有许多编程语言可供选择。但一开始就选择正确的语言是成功启动或交付的关键。选择错误的语言&#xff…
阅读更多...
用R语言进行数据类型的检查和基础转换

用R语言进行数据类型的检查和基础转换

下面内容摘录自《R 语言与数据科学的终极指南》专栏文章的部分内容&#xff0c;每篇文章都在 5000 字以上&#xff0c;质量平均分高达 94 分&#xff0c;看全文请点击下面链接&#xff1a; 4章8节&#xff1a;用R做数据重塑&#xff0c;行列命名和数据类型转换-CSDN博客 欢迎…
阅读更多...
servlet的执行顺序

servlet的执行顺序

执行的时候Tomcat先初始化 然后调用 server 根据server来回调请求方式下面会追入源码解释 package com.haogu.servlet;import javax.servlet.ServletConfig; import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.…
阅读更多...
【C++二分查找】1954. 收集足够苹果的最小花园周长

【C++二分查找】1954. 收集足够苹果的最小花园周长

本文涉及的基础知识点 C二分查找 LeetCode1954. 收集足够苹果的最小花园周长 给你一个用无限二维网格表示的花园&#xff0c;每一个 整数坐标处都有一棵苹果树。整数坐标 (i, j) 处的苹果树有 |i| |j| 个苹果。 你将会买下正中心坐标是 (0, 0) 的一块 正方形土地 &#xff…
阅读更多...
Windows平台RTSP|RTMP播放器如何实现实时录像功能

Windows平台RTSP|RTMP播放器如何实现实时录像功能

技术背景 RTSP、RTMP直播播放&#xff0c;这里不再赘述&#xff0c;我们可以很轻松的实现毫秒级的延迟体验&#xff0c;这里讲的是如何实现RTSP、RTSP流的实时录像功能。 我们理解的录像&#xff0c;可能觉得&#xff0c;只要有个开始录像、停止录像接口就够了&#xff0c;实…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023