技术路上的探险家
技术路上的探险家

「Java」《深入解析Java多线程编程利器：CompletableFuture》

《深入解析Java多线程编程利器：CompletableFuture》

  • 一、 引言
    • 1. 对多线程编程的需求和挑战的介绍
    • 2. 介绍CompletableFuture的作用和优势
  • 二. CompletableFuture简介
    • 1. CompletableFuture是Java中提供的一个强大的多线程编程工具
    • 2. 与传统的Thread和Runnable相比的优点
  • 三、基本用法
    • 1.创建CompletableFuture对象的方式
    • 2. 异步执行任务并返回结果
    • 3. 使用回调函数处理异步任务的结果
  • 四、组合多个CompletableFuture
    • 1. thenCompose()方法的使用
    • 2. thenCombine()方法的使用
    • 3. allOf()和anyOf()方法的使用
  • 五、异常处理
    • 1. exceptionally()方法的使用
    • 2. handle()方法的使用
  • 六、 CompletableFuture的进阶功能
    • 1. CompletableFuture的取消和超时处理
    • 2. CompletableFuture的并发限制
    • 3. CompletableFuture与Stream的结合使用
  • 七、 示例和案例分析
    • 1. 使用CompletableFuture实现并发下载
    • 2. 使用CompletableFuture优化订单处理流程
  • 八、总结
    • 1. 重点总结CompletableFuture的核心概念和用法
    • 2. 强调CompletableFuture在多线程编程中的价值和应用场景

一、 引言

1. 对多线程编程的需求和挑战的介绍

多线程编程是指在一个程序中同时执行多个线程来提高系统的并发性和响应性。在现代计算机系统中，多线程编程已经成为开发者日常工作的一部分。以下是对多线程编程需求和挑战的介绍：

  1. 需求：
    • 提高系统的性能：通过同时执行多个线程，可以利用多核处理器的优势，实现任务的并行执行，从而提高系统的处理速度和吞吐量。
    • 改善用户体验：多线程编程可以使图形界面或交互式应用程序更加流畅和响应，避免长时间的等待和阻塞。
    • 实现后台任务：多线程可以用于执行后台任务，如数据加载、网络通信、文件写入等，提高用户界面的反应速度，同时保持后台任务的进行。
  1. 挑战：
  • 线程同步与竞态条件：多个线程共享同一份资源时，可能会引发问题，如竞态条件、死锁和数据不一致等。需要合理地使用锁、同步机制和线程安全的数据结构来保证线程之间的正确协作。
  • 上下文切换开销：在多线程环境下，线程的调度和切换会带来一定的开销，影响系统性能。合理控制线程数量和避免过度的上下文切换是关键。
  • 调试和测试困难：多线程程序的调试和测试相对复杂，由于线程间的异步执行和并发性，可能会导致问题不易重现和定位。
  • 安全性和可靠性：多线程编程需要考虑并发访问共享资源的问题，如果处理不当，可能会导致数据不一致、内存泄漏等安全问题。同时还需保证线程的稳定性、可靠性和正确性。

了解这些需求和挑战对于进行有效的多线程编程至关重要。开发者需要熟悉并掌握多线程编程的基本概念、技术和最佳实践，以解决并发编程中的问题，并正确地利用多线程来满足系统的需求。

2. 介绍CompletableFuture的作用和优势

CompletableFuture是Java 8引入的一个强大的多线程编程工具，用于处理异步任务和并发编程。它提供了更简洁、灵活和易用的方式来处理并发操作。以下是CompletableFuture的作用和优势的介绍：

  1. 异步任务处理：CompletableFuture可以用于执行异步任务，并在任务完成时获取结果。它可以帮助开发者更方便地处理耗时的操作，避免阻塞主线程。

  2. 组合多个任务：CompletableFuture可以将多个异步任务进行链式组合，实现任务之间的顺序关系。通过一系列的方法调用，可以实现任务的串行执行、并行执行以及任务间的依赖关系。

  3. 回调函数处理：CompletableFuture支持回调函数的方式处理异步任务的结果。可以在任务完成后执行相应的回调函数，进行后续操作，例如数据处理、结果分析等。

  4. 异常处理：CompletableFuture提供了灵活的异常处理机制。可以使用exceptionally()方法或handle()方法来处理任务中的异常情况，保证程序的健壮性和稳定性。

  5. 取消和超时处理：CompletableFuture支持任务的取消和超时处理。可以设置任务的执行时间上限，如果任务无法在规定时间内完成，可以进行相应的处理操作，避免长时间的等待和占用资源。

  6. 并发限制：CompletableFuture允许开发者设置任务的并发限制，控制同时执行的任务数量。这对于任务有资源限制或对并发度有要求的场景非常有用。

  7. 整合Stream操作：CompletableFuture可以与Java 8中引入的Stream API进行无缝整合。通过CompletableFuture的一些方法，可以在流中实现并行操作，提高处理效率。

CompletableFuture作为Java多线程编程的利器，使得异步任务和并发编程变得更加直观和简单。它提供了丰富的方法来处理并发操作，并具有灵活的异常处理、任务组合和回调处理能力。使用CompletableFuture可以大大简化多线程编程的复杂性，提高开发效率和程序性能。

二. CompletableFuture简介

1. CompletableFuture是Java中提供的一个强大的多线程编程工具

CompletableFuture是Java中提供的一个强大的多线程编程工具。它位于java.util.concurrent包下，是Java 8引入的一种Future的扩展形式，用于处理异步任务和并发编程。

CompletableFuture提供了一种更简洁、灵活和易用的方式来处理异步任务。它支持链式调用和函数式编程的风格，使得编写异步代码变得更加直观和方便。

通过CompletableFuture，可以完成以下操作：

  1. 异步执行：使用supplyAsync()或runAsync()方法可以将任务提交到线程池中异步执行，这样就不会阻塞主线程。

  2. 链式操作：通过一系列的方法调用，可以将多个CompletableFuture组合在一起，形成一个任务链。例如，使用thenApply()、thenAccept()和thenCompose()等方法可以定义任务之间的依赖关系和后续操作。

  3. 异常处理：CompletableFuture提供了异常处理的机制，可以使用exceptionally()、handle()和whenComplete()等方法来处理异常情况，并在任务完成时执行相应的操作。

  4. 合并多个任务：使用allOf()、anyOf()和join()等方法可以将多个CompletableFuture进行合并和组合，实现对多个任务结果的处理。

  5. 取消和超时处理：CompletableFuture支持取消任务和设置超时时间，并提供了相应的方法来处理任务的取消和超时情况。

  6. 并发限制：可以使用CompletableFuture.supplyAsync().thenCombine()等方法来控制并发度，限制同时执行的任务数量。

CompletableFuture的引入大大简化了Java中的异步编程和并发处理，使得多线程编程变得更加方便和高效。它提供了丰富的操作方法和异常处理机制，帮助开发者更好地控制和组合异步任务，实现高效的并发编程。

2. 与传统的Thread和Runnable相比的优点

相对于传统的Thread和Runnable，CompletableFuture具有以下几个优点：

  1. 异步编程简单：CompletableFuture通过方法链的方式让异步编程变得更加直观和易于理解。开发者可以通过一系列的方法调用来组合和处理异步任务，而不需要手动管理线程和同步。

  2. 高级的任务组合：CompletableFuture提供了丰富的方法来组合多个任务，例如在一个任务完成后执行下一个任务、组合多个任务的结果等。这种链式调用的方式使得任务之间的关系更加清晰和灵活。

  3. 异常处理方便：CompletableFuture提供了专门的方法来处理异常情况。通过exceptionally()、handle()和whenComplete()等方法，可以更容易地捕获和处理任务中出现的异常。

  4. 取消和超时处理：CompletableFuture支持任务的取消和设置超时时间。可以使用cancel()方法取消任务，或者使用completeOnTimeout()方法设置任务的超时时间。这些功能在处理需要限时操作或在某些条件下需要中止任务的场景非常有用。

  5. 非阻塞主线程：CompletableFuture的任务是在一个线程池中执行的，因此不会阻塞主线程。这允许主线程继续执行其他操作，提高了应用程序的响应性能。

  6. 并发度控制：CompletableFuture提供了方式来控制任务的并发度。可以使用thenComposeAsync()、thenCombineAsync()等方法来指定异步任务在多个线程上并发执行，从而提高性能。

  7. 整合Stream API：CompletableFuture可以与Java 8中引入的Stream API无缝集成。这意味着可以在流中使用CompletableFuture来进行并行操作，进一步简化了代码的编写和处理。

总的来说，CompletableFuture相对于传统的Thread和Runnable提供了更高级、更灵活、更易于使用的异步编程解决方案。它让异步任务的编写和组合变得更加简单和直观，并提供了丰富的方法来处理异常、取消任务和控制并发度。这使得开发者能够更好地管理和利用多线程环境，提高应用程序的性能和可维护性。

三、基本用法

1.创建CompletableFuture对象的方式

创建CompletableFuture对象的方式有多种，可以根据实际需求选择适合的方式。以下是几种常见的创建CompletableFuture对象的方式：

  1. 使用CompletableFuture.supplyAsync()创建异步执行的CompletableFuture对象，该方法接收一个Supplier类型的参数，表示要执行的任务，并返回一个CompletableFuture对象。
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 异步执行的任务逻辑
    return "Hello, CompletableFuture!";
});
  1. 使用CompletableFuture.runAsync()创建异步执行的CompletableFuture对象，该方法接收一个Runnable类型的参数，表示要执行的任务，并返回一个CompletableFuture对象。
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    // 异步执行的任务逻辑
    System.out.println("Hello, CompletableFuture!");
});
  1. 使用CompletableFuture.completedFuture()创建已完成的CompletableFuture对象，该方法接收一个数值、对象或null作为参数，返回一个已经完成的CompletableFuture对象。
CompletableFuture<String> completedFuture = CompletableFuture.completedFuture("Hello");
  1. 使用CompletableFuture.newIncompleteFuture()创建一个未完成的CompletableFuture对象，以后可以通过调用其它方法来完成该对象。
CompletableFuture<String> future = new CompletableFuture<>();
// 后续在适当的时机通过调用complete方法完成该CompletableFuture对象
future.complete("Hello, CompletableFuture!");
  1. 使用CompletableFuture.allOf()和CompletableFuture.anyOf()静态方法创建组合的CompletableFuture对象。allOf()接收多个CompletableFuture对象作为参数，并返回一个新的CompletableFuture对象，该对象在所有输入的CompletableFuture对象都完成后才会完成。anyOf()类似，只要有任意一个输入的CompletableFuture对象完成，返回的对象就会完成。
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "CompletableFuture");

CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(future1, future2);
CompletableFuture<Object> anyOfFuture = CompletableFuture.anyOf(future1, future2);

这些是创建CompletableFuture对象的常见方式，根据具体的业务需求和场景，可以选择适合的方式来创建和组合CompletableFuture对象，实现异步编程和并发处理。

2. 异步执行任务并返回结果

要异步执行任务并返回结果，可以使用CompletableFuture.supplyAsync()方法创建一个CompletableFuture对象，并将要执行的任务逻辑包装在一个Supplier函数中。这个Supplier函数会在异步执行的线程中被调用，并返回计算的结果。

以下是一个示例代码：

import java.util.concurrent.CompletableFuture;

public class AsyncTaskExample {
    public static void main(String[] args) {
        // 异步执行任务
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 异步执行的任务逻辑
            return "Hello, CompletableFuture!";
        });

        // 当任务完成时获取结果
        future.thenAccept(result -> System.out.println("Result: " + result));

        // 阻塞主线程，使异步任务有足够的时间完成
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，我们使用CompletableFuture.supplyAsync()方法创建了一个CompletableFuture对象，并在Supplier函数中定义了要异步执行的任务逻辑。通过thenAccept()方法，我们注册了一个回调函数，当任务完成时会获取到计算的结果，并打印输出。

需要注意的是，在这个示例中，我们使用Thread.sleep()方法阻塞了主线程一段时间，以确保异步任务有足够的时间完成。实际使用中，主线程可能会执行其他的操作，而不必主动等待异步任务完成。

当然，CompletableFuture还提供了许多其他的方法来处理异步任务的结果，例如使用thenApply()方法对结果进行转换，使用exceptionally()方法处理异常情况等。根据具体的需求，可以选择适合的方法来处理异步任务的结果。

3. 使用回调函数处理异步任务的结果

使用回调函数处理异步任务的结果是通过在CompletableFuture对象上注册回调函数来实现的。当异步任务完成时，回调函数会被执行，并传递任务的结果作为参数。

以下是一个示例代码，演示如何使用回调函数处理异步任务的结果：

import java.util.concurrent.CompletableFuture;

public class AsyncCallbackExample {
    public static void main(String[] args) {
        // 异步执行任务
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 异步执行的任务逻辑
            return "Hello, CompletableFuture!";
        });

        // 注册回调函数处理任务结果
        future.thenAccept(result -> System.out.println("Result: " + result));

        // 阻塞主线程，使异步任务有足够的时间完成
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，我们通过thenAccept()方法在CompletableFuture对象上注册了一个回调函数。当异步任务完成后，回调函数会被执行，并将任务的结果作为参数传递给回调函数。在这个示例中，回调函数只简单地打印出结果。

需要注意的是，回调函数会在异步任务完成的线程上执行。如果回调函数需要进行耗时的操作或者阻塞，可能会影响到其他任务的执行。因此，建议在回调函数中只处理轻量级的操作，避免阻塞或耗时的操作。

除了thenAccept()方法外，CompletableFuture还提供了其他的回调函数方法，如thenApply()用于对任务结果进行转换，exceptionally()用于处理异常情况等。根据需求，选择适合的回调函数方法来处理异步任务的结果。

四、组合多个CompletableFuture

1. thenCompose()方法的使用

thenCompose()方法是CompletableFuture类提供的一个方法，用于处理异步任务的结果。它接受一个Function参数，该函数将当前CompletableFuture的结果作为输入，并返回另一个CompletableFuture对象。这个返回的CompletableFuture对象表示一个新的异步任务，可以继续执行链式操作。

下面是使用thenCompose()方法的示例代码：

import java.util.concurrent.CompletableFuture;

public class ThenComposeExample {
    public static void main(String[] args) {
        // 异步执行第一个任务
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            // 第一个任务逻辑
            return "Hello";
        });

        // 使用thenCompose()方法处理第一个任务的结果，并执行第二个任务
        CompletableFuture<String> future2 = future1.thenCompose(result -> {
            // 第二个任务逻辑，基于第一个任务的结果
            return CompletableFuture.supplyAsync(() -> result + ", CompletableFuture!");
        });

        // 当第二个任务完成时获取结果
        future2.thenAccept(result -> System.out.println("Result: " + result));

        // 阻塞主线程，使异步任务有足够的时间完成
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，我们首先使用CompletableFuture.supplyAsync()方法创建了一个异步任务future1，它简单地返回字符串"Hello"。接着，我们使用thenCompose()方法处理future1的结果，根据第一个任务的结果执行第二个任务。第二个任务通过CompletableFuture.supplyAsync()方法创建，它会将第一个任务的结果与字符串", CompletableFuture!"拼接在一起。

最后，我们使用thenAccept()方法注册了一个回调函数，在第二个任务完成时打印结果。

需要注意的是，thenCompose()方法返回的是一个新的CompletableFuture对象，表示一个新的异步任务。通过这种方式，可以方便地链式执行多个异步任务，每个任务都依赖于上一个任务的结果。

在实际应用中，可以根据具体需求来组合和处理异步任务的结果，使用thenCompose()方法来进行任务的串联和组合。

2. thenCombine()方法的使用

thenCombine()方法是CompletableFuture类提供的一个方法，用于将两个独立的异步任务的结果进行合并处理。它接受两个CompletionStage参数和一个BiFunction参数，该函数将两个任务的结果作为输入，并返回一个新的结果。

下面是使用thenCombine()方法的示例代码：

import java.util.concurrent.CompletableFuture;

public class ThenCombineExample {
    public static void main(String[] args) {
        // 异步执行第一个任务
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            // 第一个任务逻辑
            return "Hello";
        });

        // 异步执行第二个任务
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            // 第二个任务逻辑
            return "CompletableFuture!";
        });

        // 使用thenCombine()方法处理两个任务的结果
        CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (result1, result2) -> {
            // 合并处理两个任务的结果
            return result1 + ", " + result2;
        });

        // 当合并任务完成时获取结果
        combinedFuture.thenAccept(result -> System.out.println("Result: " + result));

        // 阻塞主线程，使异步任务有足够的时间完成
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，我们首先分别创建了两个独立的异步任务future1和future2，它们分别返回字符串"Hello"和"CompletableFuture!"。然后，我们使用thenCombine()方法将这两个任务的结果进行合并处理。合并的逻辑由BiFunction参数指定，它将两个任务的结果拼接起来。

最后，使用thenAccept()方法注册了一个回调函数，在合并任务完成时打印结果。

需要注意的是，thenCombine()方法返回的是一个新的CompletableFuture对象，表示一个新的异步任务。通过这种方式，可以将多个独立的异步任务的结果合并在一起，并进行后续的处理。

在实际应用中，可以根据具体需求选择使用thenCombine()方法来处理多个异步任务的结果的合并操作。

3. allOf()和anyOf()方法的使用

allOf()和anyOf()方法都是CompletableFuture类提供的静态方法，用于处理多个异步任务的结果。

allOf()方法接受一个可变参数，表示一组CompletableFuture对象，返回一个新的CompletableFuture对象。这个新的CompletableFuture对象表示一个新的异步任务，当所有输入的任务都完成时，它将完成。

下面是使用allOf()方法的示例代码：

import java.util.concurrent.CompletableFuture;

public class AllOfExample {
    public static void main(String[] args) {
        // 定义一组异步任务
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Task 1");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Task 2");
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> "Task 3");

        // 使用allOf()方法等待所有任务完成
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2, future3);

        // 当所有任务完成时执行回调函数
        allFutures.thenRun(() -> System.out.println("All tasks completed."));

        // 阻塞主线程，使异步任务有足够的时间完成
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，我们定义了三个异步任务future1、future2和future3，它们分别返回字符串"Task 1"、“Task 2"和"Task 3”。然后，我们使用allOf()方法等待所有任务完成，并返回一个CompletableFuture对象。我们可以通过这个对象注册一个回调函数，在所有任务完成时打印一条消息。

需要注意的是，allOf()方法返回的CompletableFuture对象不关心每个任务的具体结果，只关心所有任务的完成情况。

而anyOf()方法接受一个可变参数，表示一组CompletableFuture对象，返回一个新的CompletableFuture对象。这个新的CompletableFuture对象表示一个新的异步任务，当任意一个输入的任务完成时，它将完成。

下面是使用anyOf()方法的示例代码：

import java.util.concurrent.CompletableFuture;

public class AnyOfExample {
    public static void main(String[] args) {
        // 定义一组异步任务
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Task 1");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Task 2");
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> "Task 3");

        // 使用anyOf()方法等待任意一个任务完成
        CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(future1, future2, future3);

        // 当任意一个任务完成时执行回调函数
        anyFuture.thenAccept(result -> System.out.println("One task completed: " + result));

        // 阻塞主线程，使异步任务有足够的时间完成
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，我们同样定义了三个异步任务future1、future2和future3，它们分别返回字符串"Task 1"、“Task 2"和"Task 3”。然后，我们使用anyOf()方法等待任意一个任务完成，并返回一个CompletableFuture对象。我们可以通过这个对象注册一个回调函数，在任意一个任务完成时打印其结果。

需要注意的是，anyOf()方法返回的CompletableFuture对象只会关注第一个完成的任务，不会等待其他任务的完成。

通过使用allOf()和anyOf()方法，可以方便地处理多个异步任务的结果，并根据不同的需求进行相应的处理。

五、异常处理

1. exceptionally()方法的使用

exceptionally() 方法是 CompletableFuture 类提供的一个方法，它允许你在异步任务抛出异常时提供一个默认的返回值或进行异常处理。该方法接受一个函数作为参数，这个函数会在异步任务抛出异常时被调用。

下面是 exceptionally() 方法的使用示例：

import java.util.concurrent.CompletableFuture;

public class ExceptionallyExample {
    public static void main(String[] args) {
        // 定义一个异步任务
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // 任务逻辑，这里会抛出异常
            throw new RuntimeException("Task failed!");
        });

        // 使用 exceptionally() 方法处理异步任务的异常
        CompletableFuture<Integer> result = future.exceptionally(ex -> {
            // 在异常发生时处理异常并提供默认返回值
            System.out.println("Exception occurred: " + ex.getMessage());
            return 0;
        });

        // 等待异步任务完成并获取最终结果
        int value = result.join();
        System.out.println("Result: " + value);
    }
}

在上面的示例中，我们定义了一个异步任务 future，它会抛出一个运行时异常。然后，我们使用 exceptionally() 方法来处理异常，并提供一个默认的返回值。在异常发生时，异常处理函数会被调用，打印异常信息，并返回 0。最后，我们使用 join() 方法等待异步任务完成，并获取最终结果。

需要注意的是，exceptionally() 方法返回的是一个新的 CompletableFuture 对象，它表示一个新的异步任务。这个新的任务在原始任务抛出异常时会被触发，并执行异常处理函数。

使用 exceptionally() 方法可以方便地处理异步任务的异常情况，提供默认的返回值或进行异常处理，从而保证程序的可靠性和稳定性。

2. handle()方法的使用

六、 CompletableFuture的进阶功能

1. CompletableFuture的取消和超时处理

handle() 方法是 CompletableFuture 类提供的一个方法，它可以在异步任务完成后对结果进行处理，无论是否出现异常。相比于 exceptionally() 方法，handle() 方法可以处理正常结果和异常情况。

handle() 方法接受一个函数作为参数，这个函数会在异步任务完成后被调用，并接收任务的结果作为输入参数。这个函数可以返回一个结果，作为最终的处理结果。

下面是 handle() 方法的使用示例：

import java.util.concurrent.CompletableFuture;

public class HandleExample {
    public static void main(String[] args) {
        // 定义一个异步任务
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // 任务逻辑，这里可能会抛出异常
            return 10;
        });

        // 使用 handle() 方法处理异步任务的结果和异常
        CompletableFuture<String> result = future.handle((value, ex) -> {
            if (ex != null) {
                // 异常处理
                System.out.println("Exception occurred: " + ex.getMessage());
                return "Default Value";
            } else {
                // 正常结果处理
                return "Result: " + value;
            }
        });

        // 等待异步任务完成并获取最终结果
        String finalResult = result.join();
        System.out.println(finalResult);
    }
}

在上面的示例中，我们定义了一个异步任务 future，它会返回一个整数。然后，我们使用 handle() 方法来处理异步任务的结果和异常。在处理函数中，首先判断异常是否为 null，如果不为 null，则表示任务发生了异常，我们可以在这里进行异常处理，并返回一个默认值。如果异常为 null，则表示任务执行正常，我们可以在这里对正常结果进行处理，并返回相应的字符串。

最后，使用 join() 方法等待异步任务完成，并获取最终的处理结果。

需要注意的是，handle() 方法返回的是一个新的 CompletableFuture 对象，它表示一个新的异步任务。这个新的任务会在原始任务完成后被触发，并执行处理函数。

通过使用 handle() 方法，我们可以灵活地处理异步任务的结果和异常，提供自定义的处理逻辑，从而实现更加复杂的业务需求。

2. CompletableFuture的并发限制

CompletableFuture 类本身并没有提供直接的并发限制功能。它是 Java 中用于处理异步编程的工具类，通过 CompletableFuture 可以方便地进行异步任务的组合、串行化、并行化等操作。

如果你需要对异步任务进行并发限制，可以借助 Executor 框架提供的线程池来实现。Executors 类提供了一些静态方法来创建不同类型的线程池，其中的线程池可以控制并发执行的任务数量。

下面是一个使用 Executors 创建固定大小线程池来限制 CompletableFuture 并发的示例：

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

public class ConcurrentLimitExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 创建多个 CompletableFuture，并指定线程池
        CompletableFuture<Void> task1 = CompletableFuture.runAsync(() -> {
            // 异步任务逻辑
            System.out.println("Task 1");
        }, executor);

        CompletableFuture<Void> task2 = CompletableFuture.runAsync(() -> {
            // 异步任务逻辑
            System.out.println("Task 2");
        }, executor);

        CompletableFuture<Void> task3 = CompletableFuture.runAsync(() -> {
            // 异步任务逻辑
            System.out.println("Task 3");
        }, executor);

        // 等待所有 CompletableFuture 完成
        CompletableFuture.allOf(task1, task2, task3)
                .join();

        // 关闭线程池
        executor.shutdown();
    }
}

在上面的示例中，我们使用 Executors.newFixedThreadPool(5) 创建一个固定大小为 5 的线程池。然后，我们创建了多个 CompletableFuture 对象，并通过指定线程池来执行异步任务。通过这种方式，我们可以控制并发执行的任务数量，限制在线程池提供的线程数范围内。

需要注意的是，通过线程池控制并发执行的任务数量是有限度的，取决于线程池的配置和硬件资源。如果任务数超过了线程池的容量，超出部分的任务会进入等待队列，直到有空闲线程可用。

使用线程池来限制 CompletableFuture 的并发操作可以帮助控制资源的使用，防止资源过度消耗和线程过多导致的性能问题。

3. CompletableFuture与Stream的结合使用

CompletableFuture 和 Stream 是 Java 中两个强大且灵活的工具，它们可以很好地结合使用，以实现异步处理和流式操作的组合。下面是一些使用 CompletableFuture 和 Stream 结合的示例：

  1. 异步任务的并行处理：
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

public class CompletableFutureWithStream {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);

        // 使用 CompletableFuture 来异步处理每个元素
        List<CompletableFuture<String>> futures = numbers.stream()
                .map(number -> CompletableFuture.supplyAsync(() -> process(number)))
                .collect(Collectors.toList());

        // 等待所有 CompletableFuture 完成，并获取结果列表
        List<String> results = futures.stream()
                .map(CompletableFuture::join)
                .collect(Collectors.toList());

        // 打印结果
        results.forEach(System.out::println);
    }

    private static String process(Integer number) {
        // 模拟一个耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "Processed: " + number;
    }
}

在上述示例中，我们使用 CompletableFuture 的 supplyAsync() 方法来创建异步任务，并通过 Stream 的 map() 方法将每个元素映射成对应的 CompletableFuture。然后，我们将这些 CompletableFuture 收集到一个列表中。

接着，我们通过 Stream 的 map() 方法将列表中的 CompletableFuture 转换为实际的结果，并将结果收集到另一个列表中。最后，我们打印出每个结果。

这样的方式可以实现异步任务的并行处理，提高处理效率。

  1. 异步任务的顺序处理：
import java.util.List;
import java.util.concurrent.CompletableFuture;

public class CompletableFutureWithStream {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);

        CompletableFuture<Void> future = CompletableFuture.completedFuture(null); // 创建一个已完成的 CompletableFuture

        // 顺序处理每个元素的异步任务
        for (Integer number : numbers) {
            future = future.thenComposeAsync(result -> CompletableFuture.supplyAsync(() -> process(number)));
        }

        // 等待最后一个 CompletableFuture 完成
        future.join();
    }

    private static String process(Integer number) {
        // 模拟一个耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Processed: " + number);
        return null;
    }
}

在上述示例中，我们使用一个已完成的 CompletableFuture 作为起点。然后，我们在循环中以顺序的方式将每个元素的异步任务连接起来，通过 thenComposeAsync() 方法将每个异步任务串联起来。

通过这样的方式，每个异步任务都会等待前一个任务完成后才会触发执行，从而实现了顺序处理的效果。

需要注意的是，在顺序处理的情况下，后续的异步任务会等待前一个任务完成后才会被触发，所以整体的执行时间会比并行处理长。这取决于异步任务的耗时和处理逻辑。

通过 CompletableFuture 和 Stream 的结合使用，可以快速实现复杂的异步处理和流式操作。你可以根据具体的需求和业务场景选择合适的方式来组合它们。

七、 示例和案例分析

1. 使用CompletableFuture实现并发下载

使用 CompletableFuture 来实现并发下载是一个很常见的场景，下面是一个使用 CompletableFuture 实现并发下载的示例：

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConcurrentDownloader {
    public static void main(String[] args) {
        List<String> urls = Arrays.asList(
                "https://example.com/image1.jpg",
                "https://example.com/image2.jpg",
                "https://example.com/image3.jpg"
        );

        // 创建固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 使用 CompletableFuture 并发下载图片
        List<CompletableFuture<Void>> downloadFutures = urls.stream()
                .map(url -> CompletableFuture.runAsync(() -> downloadImage(url), executor))
                .toList();

        // 等待所有 CompletableFuture 完成
        CompletableFuture.allOf(downloadFutures.toArray(new CompletableFuture[0]))
                .join();

        // 关闭线程池
        executor.shutdown();
    }

    private static void downloadImage(String url) {
        try (InputStream in = new URL(url).openStream();
             FileOutputStream out = new FileOutputStream(getFileName(url))) {
            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = in.read(buffer)) != -1) {
                out.write(buffer, 0, bytesRead);
            }
            System.out.println("Downloaded: " + url);
        } catch (IOException e) {
            System.err.println("Failed to download image: " + url);
        }
    }

    private static String getFileName(String url) {
        String[] segments = url.split("/");
        return segments[segments.length - 1];
    }
}

在上述示例中，我们首先创建了一个包含要下载图片的 URL 列表。然后，我们创建了一个固定大小的线程池，通过 Executors.newFixedThreadPool(3) 创建了一个大小为 3 的线程池。

接下来，我们使用 CompletableFuture 和 Stream 的结合来并发下载图片。通过 CompletableFuture.runAsync() 方法将下载图片的逻辑包装成一个异步任务，并指定线程池执行该任务。然后，将所有的 CompletableFuture 收集到一个列表中。

最后，我们使用 CompletableFuture.allOf() 方法来等待所有的 CompletableFuture 完成，并通过 join() 方法阻塞当前线程，直到所有任务完成。

需要注意的是，并发下载图片涉及到网络 IO 操作，可能会耗费较长的时间。为了避免阻塞主线程，我们采用了异步的方式进行下载，并且使用了线程池来控制并发执行的任务数量。

通过 CompletableFuture 的使用，我们可以简洁地实现并发下载的功能，并可以灵活地控制并发度和线程池的大小。这样可以提高下载效率，并充分利用可用的资源。

2. 使用CompletableFuture优化订单处理流程

使用 CompletableFuture 可以优化订单处理流程，提高效率和并发性。下面是一个使用 CompletableFuture 优化订单处理流程的示例：

假设有一个订单处理系统，包含以下几个步骤：验证订单、扣除库存、生成发货单、发送通知。

import java.util.concurrent.CompletableFuture;

public class OrderProcessing {
    public static void main(String[] args) {
        CompletableFuture<Void> orderProcessingFuture = CompletableFuture.completedFuture(null);

        // 验证订单
        orderProcessingFuture = orderProcessingFuture.thenComposeAsync(result -> CompletableFuture.supplyAsync(() -> validateOrder()))
                .thenApplyAsync(result -> {
                    if (result) {
                        System.out.println("订单验证通过");
                    } else {
                        System.out.println("订单验证失败");
                    }
                    return result;
                });

        // 扣除库存
        orderProcessingFuture = orderProcessingFuture.thenComposeAsync(result -> CompletableFuture.supplyAsync(() -> deductInventory()))
                .thenAcceptAsync(result -> {
                    if (result) {
                        System.out.println("库存扣除成功");
                    } else {
                        System.out.println("库存扣除失败");
                    }
                });

        // 生成发货单
        orderProcessingFuture = orderProcessingFuture.thenComposeAsync(result -> CompletableFuture.supplyAsync(() -> generateInvoice()))
                .thenAcceptAsync(invoice -> {
                    System.out.println("发货单生成成功：" + invoice);
                });

        // 发送通知
        orderProcessingFuture = orderProcessingFuture.thenRunAsync(() -> sendNotification());

        // 等待订单处理完成
        orderProcessingFuture.join();
    }

    private static boolean validateOrder() {
        // 模拟订单验证操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return true;
    }

    private static boolean deductInventory() {
        // 模拟扣除库存操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return true;
    }

    private static String generateInvoice() {
        // 模拟生成发货单操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "Invoice-123456";
    }

    private static void sendNotification() {
        // 模拟发送通知操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("通知已发送");
    }
}

在上述示例中，我们通过 CompletableFuture 来优化订单处理流程。每个步骤都被封装为一个异步任务，并使用 thenComposeAsync() 方法将前一个任务的结果传递给下一个任务。同时，通过 thenApplyAsync()、thenAcceptAsync() 和 thenRunAsync() 方法可以在任务完成后执行相应的操作。

在验证订单、扣除库存和生成发货单这些关键步骤中，我们使用 CompletableFuture.supplyAsync() 方法来创建异步任务。这些任务会异步地执行相关操作，并返回结果或者不返回。

最后，在订单处理完成后，我们使用 join() 方法阻塞主线程，等待所有任务完成。

通过使用 CompletableFuture，我们可以以一种非常直观和简洁的方式组织和优化订单处理流程。异步任务的执行不会阻塞主线程，可以提高并发性和系统的响应能力。

八、总结

1. 重点总结CompletableFuture的核心概念和用法

CompletableFuture 是 Java 8 引入的一个用于处理异步编程的工具类，它提供了丰富的方法来处理异步任务和操作结果。下面是 CompletableFuture 的核心概念和用法的总结：

  1. 异步任务的创建：使用 CompletableFuture.supplyAsync()、CompletableFuture.runAsync() 或
    CompletableFuture.completedFuture() 方法来创建异步任务。supplyAsync() 和
    runAsync() 分别用于有返回值和无返回值的异步任务的创建。

  2. 异步任务的串行关系：通过 thenApply()、thenAccept()、thenRun() 方法将一个任务与另一个任务进行串联。thenApply() 用于对上一个任务的结果进行转换，thenAccept()
    用于消费上一个任务的结果，thenRun() 用于在上一个任务完成后执行一段代码。

  3. 异步任务的并行关系：通过 thenCombine()、thenAcceptBoth()、runAfterBoth() 等方法将多个任务进行组合。这些方法用于在多个任务之间建立依赖关系，并在它们都完成后进行相应的操作。

  4. 异步任务的异常处理：使用 exceptionally() 方法或 handle() 方法来处理异步任务中的异常。exceptionally() 方法用于处理异常，并返回一个默认值，handle()
    方法可以处理异常，并提供一个替代的计算结果。

  5. 异步任务的等待和合并：使用 join() 方法等待一个任务的完成，并获取其结果。使用 allOf() 方法等待多个任务的完成，或者使用 anyOf() 方法等待任意一个任务的完成。

  6. 异步任务的组合和并发控制：使用 thenCompose()、thenCombine()、allOf() 等方法对多个任务进行组合和并发控制。thenCompose()
    用于将前一个任务的结果作为下一个任务的输入，thenCombine() 用于将两个任务的结果进行合并，allOf()
    用于等待多个任务的完成。

  7. 线程池的使用：可以通过 CompletableFuture.runAsync()、CompletableFuture.supplyAsync() 或
    CompletableFuture.thenRunAsync() 等方法指定自定义的线程池来执行异步任务。

CompletableFuture 提供了一种方便而强大的方式来处理异步编程，可以避免显式地使用线程或回调函数来处理异步操作。它具有丰富的方法和组合功能，可以实现复杂的异步流程控制和并发控制。通过合理地应用 CompletableFuture，我们可以提高程序的性能和可读性。

2. 强调CompletableFuture在多线程编程中的价值和应用场景

CompletableFuture 在多线程编程中具有重要的价值和广泛的应用场景。下面是强调 CompletableFuture 在多线程编程中的价值和常见的应用场景：

  1. 并行任务执行：CompletableFuture 可以方便地启动多个异步任务，并发地执行它们，从而提高系统的并发性和吞吐量。通过将任务串联或组合起来，可以构建复杂的任务流水线和并发控制逻辑。

  2. 异步操作与非阻塞调用：CompletableFuture 支持异步任务的创建和执行，可以在异步任务执行过程中继续执行其他操作，而不需要显式地创建和管理线程。这样可以避免阻塞主线程，提高系统的响应能力和资源利用率。

  3. 响应式编程：CompletableFuture 的链式操作和回调函数机制使其非常适合用于实现响应式编程模型。我们可以通过 thenApply、thenAccept、thenRun 等方法定义异步任务的处理逻辑，并在任务完成后自动触发回调函数进行后续的操作。

  4. 异常处理和容错机制：CompletableFuture 提供了丰富的异常处理方法，例如 exceptionally、handle 等，可以方便地处理异步任务中出现的异常，并提供默认值或备用计算结果。这样可以增强程序的健壮性和容错性。

  5. 并发控制和任务合并：CompletableFuture 提供了多种方法来控制异步任务的并发度，例如 thenCompose、thenCombine、allOf 等。通过合理地组合和并发控制，可以实现更高效的任务调度和资源管理。

  6. 自定义线程池：CompletableFuture 允许我们通过指定自定义的 Executor 来执行异步任务，从而可以灵活地控制线程池的大小、线程池的属性等，以满足应用程序的需求。

  7. 异步 I/O 操作：CompletableFuture 还可以与异步 I/O 操作结合使用，例如与 NIO 的 AsynchronousFileChannel、AsynchronousSocketChannel 等配合，实现高效的异步文件读写和网络通信。

CompletableFuture 在多线程编程中具有强大的功能和灵活的应用场景。它简化了异步编程的复杂性，提高了代码的可读性和可维护性，同时也提升了系统的性能和并发性。无论是对于高并发的服务器端应用，还是对于异步处理的客户端应用，CompletableFuture 都是一个强大的工具。

你可能感兴趣的:(JAVA,Java问题集,#,多线程,java,python,开发语言)

  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • python os.environ 江湖偌大 python深度学习
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • python八股文面试题分享及解析(1) Shawn________ python
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • Python 实现图片裁剪（附代码） | Python工具 剑客阿良_ALiang
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • Python中深拷贝与浅拷贝的区别 yuxiaoyu.
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
  • 312个免费高速HTTP代理IP（能隐藏自己真实IP地址） yangshangchuan 高速免费superwordHTTP代理
        124.88.67.20:843 190.36.223.93:8080 117.147.221.38:8123 122.228.92.103:3128 183.247.211.159:8123 124.88.67.35:81 112.18.51.167:8123 218.28.96.39:3128 49.94.160.198:3128 183.20
  • pull解析和json编码 百合不是茶 androidpull解析json
    n.json文件: [{name:java,lan:c++,age:17},{name:android,lan:java,age:8}]   pull.xml文件 <?xml version="1.0" encoding="utf-8"?> <stu>     <name>java
  • [能源与矿产]石油与地球生态系统 comsci 能源
          按照苏联的科学界的说法,石油并非是远古的生物残骸的演变产物,而是一种可以由某些特殊地质结构和物理条件生产出来的东西,也就是说,石油是可以自增长的....       那么我们做一个猜想: 石油好像是地球的体液,我们地球具有自动产生石油的某种机制,只要我们不过量开采石油,并保护好
  • 类与对象浅谈 沐刃青蛟 java基础
           类，字面理解，便是同一种事物的总称，比如人类，是对世界上所有人的一个总称。而对象，便是类的具体化，实例化，是一个具体事物，比如张飞这个人，就是人类的一个对象。但要注意的是：张飞这个人是对象，而不是张飞，张飞只是他这个人的名字，是他的属性而已。而一个类中包含了属性和方法这两兄弟，他们分别用来描述对象的行为和性质（感觉应该是
  • 新站开始被收录后，我们应该做什么？ IT独行者 PHPseo
    新站开始被收录后，我们应该做什么？         百度终于开始收录自己的网站了，作为站长，你是不是觉得那一刻很有成就感呢，同时，你是不是又很茫然，不知道下一步该做什么了？至少我当初就是这样，在这里和大家一份分享一下新站收录后，我们要做哪些工作。       至于如何让百度快速收录自己的网站，可以参考我之前的帖子《新站让百
  • oracle 连接碰到的问题 文强chu oracle
    Unable to find a java Virtual Machine－－安装64位版Oracle11gR2后无法启动SQLDeveloper的解决方案 作者：草根IT网 来源：未知 人气：813标签： 导读：安装64位版Oracle11gR2后发现启动SQLDeveloper时弹出配置java.exe的路径，找到Oracle自带java.exe后产生的路径“C:\app\用户名\prod
  • Swing中按ctrl键同时移动鼠标拖动组件（类中多借口共享同一数据） 小桔子 java继承swing接口监听
            都知道java中类只能单继承，但可以实现多个接口，但我发现实现多个接口之后，多个接口却不能共享同一个数据，应用开发中想实现：当用户按着ctrl键时，可以用鼠标点击拖动组件，比如说文本框。 编写一个监听实现KeyListener,NouseListener,MouseMotionListener三个接口，重写方法。定义一个全局变量boolea
  • linux常用的命令 aichenglong linux常用命令
    1 startx切换到图形化界面 2 man命令:查看帮助信息 man 需要查看的命令,man命令提供了大量的帮助信息,一般可以分成4个部分 name:对命令的简单说明 synopsis:命令的使用格式说明 description:命令的详细说明信息 options:命令的各项说明 3 date:显示时间 语法：date [OPTION]... [+FORMAT]
  • eclipse内存优化 AILIKES javaeclipsejvmjdk
    一 基本说明      在JVM中，总体上分2块内存区,默认空余堆内存小于 40%时，JVM就会增大堆直到-Xmx的最大限制；空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制。     1)堆内存(Heap memory):堆是运行时数据区域，所有类实例和数组的内存均从此处分配,是Java代码可及的内存，是留给开发人
  • 关键字的使用探讨 百合不是茶 关键字
    //关键字的使用探讨/*访问关键词private 只能在本类中访问public 只能在本工程中访问protected 只能在包中和子类中访问默认的 只能在包中访问*//*final   类 方法 变量 final 类 不能被继承 final 方法 不能被子类覆盖，但可以继承 final 变量 只能有一次赋值，赋值后不能改变 final 不能用来修饰构造方法*///this()
  • JS中定义对象的几种方式 bijian1013 js
        1. 基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)： <html> <head> <title>基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)</title> </head> <script> var obj = new Object();
  • 表驱动法实例 bijian1013 java表驱动法TDD
    获得月的天数是典型的直接访问驱动表方式的实例，下面我们来展示一下： MonthDaysTest.java package com.study.test; import org.junit.Assert; import org.junit.Test; import com.study.MonthDays; public class MonthDaysTest { @T
  • LInux启停重启常用服务器的脚本 bit1129 linux
    启动，停止和重启常用服务器的Bash脚本，对于每个服务器，需要根据实际的安装路径做相应的修改   #! /bin/bash Servers=(Apache2, Nginx, Resin, Tomcat, Couchbase, SVN, ActiveMQ, Mongo); Ops=(Start, Stop, Restart); currentDir=$(pwd); echo
  • 【HBase六】REST操作HBase bit1129 hbase
    HBase提供了REST风格的服务方便查看HBase集群的信息，以及执行增删改查操作   1. 启动和停止HBase REST 服务 1.1 启动REST服务 前台启动（默认端口号8080） [hadoop@hadoop bin]$ ./hbase rest start   后台启动 hbase-daemon.sh start rest   启动时指定
  • 大话zabbix 3.0设计假设 ronin47
    What’s new in Zabbix 2.0? 去年开始使用Zabbix的时候，是1.8.X的版本，今年Zabbix已经跨入了2.0的时代。看了2.0的release notes，和performance相关的有下面几个：          :: Performance improvements::Trigger related da
  • http错误码大全 byalias http协议javaweb
    响应码由三位十进制数字组成，它们出现在由HTTP服务器发送的响应的第一行。 响应码分五种类型，由它们的第一位数字表示： 1）1xx：信息，请求收到，继续处理 2）2xx：成功，行为被成功地接受、理解和采纳 3）3xx：重定向，为了完成请求，必须进一步执行的动作 4）4xx：客户端错误，请求包含语法错误或者请求无法实现 5）5xx：服务器错误，服务器不能实现一种明显无效的请求
  • J2EE设计模式-Intercepting Filter bylijinnan java设计模式数据结构
    Intercepting Filter类似于职责链模式 有两种实现 其中一种是Filter之间没有联系，全部Filter都存放在FilterChain中，由FilterChain来有序或无序地把把所有Filter调用一遍。没有用到链表这种数据结构。示例如下： package com.ljn.filter.custom; import java.util.ArrayList;
  • 修改jboss端口 chicony jboss
    修改jboss端口   %JBOSS_HOME%\server\{服务实例名}\conf\bindingservice.beans\META-INF\bindings-jboss-beans.xml   中找到 <!-- The ports-default bindings are obtained by taking the base bindin
  • c++ 用类模版实现数组类 CrazyMizzz C++
    最近c++学到数组类，写了代码将他实现，基本具有vector类的功能 #include<iostream> #include<string> #include<cassert> using namespace std; template<class T> class Array { public: //构造函数
  • hadoop dfs.datanode.du.reserved 预留空间配置方法 daizj hadoop预留空间
    对于datanode配置预留空间的方法 为：在hdfs-site.xml添加如下配置  <property>     <name>dfs.datanode.du.reserved</name>     <value>10737418240</value>    
  • mysql远程访问的设置 dcj3sjt126com mysql防火墙
    第一步: 激活网络设置 你需要编辑mysql配置文件my.cnf. 通常状况，my.cnf放置于在以下目录： /etc/mysql/my.cnf (Debian linux) /etc/my.cnf （Red Hat Linux/Fedora Linux) /var/db/mysql/my.cnf (FreeBSD) 然后用vi编辑my.cnf，修改内容从以下行： [mysqld] 你所需要: 1
  • ios 使用特定的popToViewController返回到相应的Controller dcj3sjt126com controller
    1、取navigationCtroller中的Controllers NSArray * ctrlArray = self.navigationController.viewControllers; 2、取出后，执行， [self.navigationController popToViewController:[ctrlArray objectAtIndex:0] animated:YES
  • Linux正则表达式和通配符的区别 eksliang 正则表达式通配符和正则表达式的区别通配符
    转载请出自出处：http://eksliang.iteye.com/blog/1976579 首先得明白二者是截然不同的 通配符只能用在shell命令中,用来处理字符串的的匹配。 判断一个命令是否为bash shell(linux 默认的shell)的内置命令 type -t commad 返回结果含义 file  表示为外部命令 alias  表示该
  • Ubuntu Mysql Install and CONF gengzg Install
    http://www.navicat.com.cn/download/navicat-for-mysql Step1: 下载Navicat ，网址：http://www.navicat.com/en/download/download.html Step2：进入下载目录，解压压缩包：tar -zxvf navicat11_mysql_en.tar.gz
  • 批处理，删除文件bat huqiji windowsdos
    @echo off ::演示：删除指定路径下指定天数之前（以文件名中包含的日期字符串为准）的文件。 ::如果演示结果无误，把del前面的echo去掉，即可实现真正删除。 ::本例假设文件名中包含的日期字符串（比如：bak-2009-12-25.log） rem 指定待删除文件的存放路径 set SrcDir=C:/Test/BatHome rem 指定天数 set DaysAgo=1
  • 跨浏览器兼容的HTML5视频音频播放器 天梯梦 html5
    HTML5的video和audio标签是用来在网页中加入视频和音频的标签，在支持html5的浏览器中不需要预先加载Adobe Flash浏览器插件就能轻松快速的播放视频和音频文件。而html5media.js可以在不支持html5的浏览器上使video和audio标签生效。   How to enable <video> and <audio> tags in
  • Bundle自定义数据传递 hm4123660 androidSerializable自定义数据传递BundleParcelable
          我们都知道Bundle可能过put****()方法添加各种基本类型的数据，Intent也可以通过putExtras(Bundle)将数据添加进去，然后通过startActivity()跳到下一下Activity的时候就把数据也传到下一个Activity了。如传递一个字符串到下一个Activity   把数据放到Intent
  • C＃：异步编程和线程的使用（.NET 4.5 ） powertoolsteam .net线程C#异步编程
    异步编程和线程处理是并发或并行编程非常重要的功能特征。为了实现异步编程，可使用线程也可以不用。将异步与线程同时讲，将有助于我们更好的理解它们的特征。 本文中涉及关键知识点 1. 异步编程 2. 线程的使用 3. 基于任务的异步模式 4. 并行编程 5. 总结 异步编程 什么是异步操作？异步操作是指某些操作能够独立运行，不依赖主流程或主其他处理流程。通常情况下，C＃程序
  • spark 查看 job history 日志 Stark_Summer 日志sparkhistoryjob
    SPARK_HOME/conf 下: spark-defaults.conf 增加如下内容 spark.eventLog.enabled true spark.eventLog.dir hdfs://master:8020/var/log/spark spark.eventLog.compress true spark-env.sh 增加如下内容 export SP
  • SSH框架搭建 wangxiukai2015eye springHibernatestruts
    MyEclipse搭建SSH框架 Struts Spring Hibernate 1、new一个web project。 2、右键项目，为项目添加Struts支持。    选择Struts2 Core Libraries -<MyEclipes-Library>      点击Finish。src目录下多了struts