Java异步编程之利器：Guava异步编程实践

news2024/11/28 4:39:46

第1章：引言 - 为什么要用Guava进行异步编程？

大家好，我是小黑！今天咱们要聊的是Guava在异步编程中的应用。首先，让我们搞清楚为什么要用Guava来处理异步任务。在Java的世界里，异步编程是个老话题了，但它依旧非常关键。它能让咱们的应用更高效，尤其是在处理那些耗时的I/O操作时。但传统的Java Future提供的功能太基础了，用起来有点儿笨重，而Guava的ListenableFuture就像一股清流，给异步编程带来了更多的灵活性和控制能力。

为什么这么说呢？Guava的异步编程工具不仅仅让代码看起来更简洁，还提供了更强大的功能，比如可以添加回调函数，组合多个异步操作，甚至更优雅的异常处理。想象一下，咱们的程序正在处理一堆数据，突然需要调用一个远程服务或者读写大文件，如果都用同步方式，那用户体验肯定大打折扣。但有了Guava，这一切都变得简单而高效了！

Guava的异步编程不仅仅是一种技术选择，更是一种让代码更高效、更易维护的编程方式。现在，让我们一起深入了解一下Guava的异步编程如何运作的吧！

第2章：Guava异步编程基础

咱们首先得了解Guava在异步编程中的基石——ListenableFuture。这是什么东西呢？简单说，它是Java原生Future的增强版。在Java的Future中，你得不停地检查操作是否完成，这不仅效率低下，而且代码可读性也差。但Guava的ListenableFuture就不一样了，它允许咱们注册回调函数，一旦异步操作完成，立即得到通知，多酷啊！

来，看看怎么用。首先咱们需要一个ListeningExecutorService，这是Guava提供的专门用于ListenableFuture的执行器。看下面这段代码：

ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));

这里，小黑创建了一个线程池，并用Guava的listeningDecorator方法装饰它，使其能返回ListenableFuture。下一步，咱们提交一个任务：

ListenableFuture<String> future = service.submit(new Callable<String>() {
    @Override
    public String call() throws Exception {
        // 模拟一些长时间的操作
        Thread.sleep(2000);
        return "Hello, Guava!";
    }
});

在这个例子中，小黑提交了一个Callable任务，它会睡眠2秒后返回一条消息。这就是基本的异步操作。但Guava的魅力在于它能让咱们添加回调，处理异步操作的结果或者异常：

Futures.addCallback(future, new FutureCallback<String>() {
    @Override
    public void onSuccess(String result) {
        // 当异步任务成功完成时，这里会被调用
        System.out.println("异步处理成功，结果是：" + result);
    }

    @Override
    public void onFailure(Throwable t) {
        // 异常处理
        t.printStackTrace();
    }
}, service);

在这段代码里，小黑用Futures.addCallback给future添加了一个回调。这样，一旦异步任务完成，无论是成功还是失败，相应的方法都会被调用。这样的处理方式既简洁又高效。

第3章：实现异步任务

咱们继续深入Guava的异步编程。在第二章节，小黑给大家介绍了Guava的ListenableFuture基础，那现在，咱们来看看如何实际实现一个异步任务。

首先，创建一个异步任务并不复杂。咱们需要一个Callable或Runnable任务，然后通过ListeningExecutorService提交它。这听起来跟Java的ExecutorService差不多，但Guava的妙处在于它返回的是一个ListenableFuture对象。看看下面的例子：

Callable<String> task = () -> {
    // 假设这里是一些耗时的计算
    Thread.sleep(2000);
    return "任务完成";
};

ListeningExecutorService executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(5));
ListenableFuture<String> future = executorService.submit(task);

这里，小黑创建了一个简单的Callable任务，模拟了一个耗时2秒的操作。然后用MoreExecutors.listeningDecorator装饰了一个固定大小的线程池，以便提交ListenableFuture任务。

接下来的重点是如何管理这些异步任务。Guava提供了很棒的工具来处理这个问题，比如我们可以轻松地添加回调函数、等待任务完成，甚至是组合多个任务。但在此之前，咱们需要了解一下ListenableFuture的基本操作。

比如，咱们想要获取任务的结果，可以使用future.get()方法。但要注意，这个方法会阻塞当前线程直到任务完成。这在某些场景下可能不是最佳选择，特别是当你不想让当前线程等待时。Guava在这里提供了一个非阻塞的方案，那就是Futures.addCallback，这样可以在任务完成时立即得到通知，而不阻塞当前线程。

Futures.addCallback(future, new FutureCallback<String>() {
    public void onSuccess(String result) {
        // 当任务成功完成时调用
        System.out.println("结果: " + result);
    }

    public void onFailure(Throwable thrown) {
        // 当任务执行异常时调用
        thrown.printStackTrace();
    }
}, executorService);

在这段代码中，小黑为future添加了一个回调。这样一旦任务完成，无论成功还是失败，相应的回调方法就会被执行。这种方式让异步编程变得更加灵活和强大。使用Guava的ListenableFuture，咱们可以优雅地处理异步任务，编写出更清晰、更健壮的代码。

第4章：异步回调与转换

好了，现在小黑带大家进入Guava异步编程的下一环节：异步回调与转换。这部分内容非常有趣，也是Guava异步编程中最强大的特性之一。咱们知道，在传统的Java异步编程中，处理异步任务的结果往往需要阻塞等待，而Guava通过回调机制提供了一种更灵活、非阻塞的方式来处理这些结果。

回调函数的使用

首先，看看如何给一个异步任务添加回调函数。咱们已经知道了ListenableFuture，那就让我们用它来实践一下。假设小黑有一个异步任务，这个任务完成后，咱们想要做一些额外的处理，比如记录日志或者通知用户。

ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));
ListenableFuture<String> future = service.submit(() -> {
    // 这里模拟一个耗时操作
    Thread.sleep(2000);
    return "任务完成";
});

Futures.addCallback(future, new FutureCallback<String>() {
    @Override
    public void onSuccess(String result) {
        // 这里处理任务成功完成的情况
        System.out.println("异步任务成功完成，结果是：" + result);
    }

    @Override
    public void onFailure(Throwable thrown) {
        // 这里处理任务失败的情况
        System.err.println("异步任务失败，错误：" + thrown.getMessage());
    }
}, service);

在这个例子中，咱们提交了一个异步任务，并通过Futures.addCallback为它添加了一个回调。这样一来，任务完成时，无论成功还是失败，对应的方法都会被执行，而且不会阻塞咱们的主线程。

异步结果的转换

另一个有趣的特性是结果转换。在某些情况下，咱们可能需要将异步任务的输出转换成另一种格式或类型。Guava的Futures.transform方法在这里就派上用场了。看看下面这个例子：

ListenableFuture<String> transformedFuture = Futures.transform(future, new Function<String, String>() {
    @Override
    public String apply(String input) {
        // 这里将输入转换为大写
        return input.toUpperCase();
    }
}, service);

// 添加回调以处理转换后的结果
Futures.addCallback(transformedFuture, new FutureCallback<String>() {
    @Override
    public void onSuccess(String result) {
        System.out.println("转换后的结果：" + result);
    }

    @Override
    public void onFailure(Throwable t) {
        System.err.println("转换失败：" + t.getMessage());
    }
}, service);

在这个例子中，咱们使用了Futures.transform来将原始异步任务的结果转换成大写。这样的转换是非阻塞的，并且可以链式调用，非常方便。

Guava允许咱们灵活地管理和操作异步任务的结果，使得代码更加简洁和易于维护。这种方式不仅提高了代码的可读性，也提升了编程的效率。

第5章：错误处理和异常管理

当咱们谈论异步编程，一个不得不提的话题就是错误处理和异常管理。在传统的同步编程中，咱们通常会用try-catch块来处理异常。但在异步编程中，事情会稍微复杂一些。好消息是，Guava提供了一些非常实用的工具来帮助咱们在异步环境中更加优雅地处理异常。

异常处理策略

在Guava的ListenableFuture中，如果异步任务执行过程中发生异常，这个异常会被封装在Future中。调用者可以通过future.get()方法来获取结果，如果有异常发生，它会被抛出。但这种方式会阻塞调用线程，而且不是很灵活。Guava提供了更好的方法来处理这些异常。

让小黑来展示一个例子。假设有一个异步任务，它可能会抛出一个异常。咱们可以用Futures.catching来优雅地处理它：

ListenableFuture<String> future = service.submit(() -> {
    if (new Random().nextBoolean()) {
        throw new IllegalStateException("糟糕，出错了！");
    }
    return "一切正常";
});

// 使用Futures.catching处理异常
ListenableFuture<String> catchingFuture = Futures.catching(future, IllegalStateException.class, 
    (Exception e) -> "出现异常，但被处理了！", service);

Futures.addCallback(catchingFuture, new FutureCallback<String>() {
    @Override
    public void onSuccess(String result) {
        System.out.println("结果：" + result);
    }

    @Override
    public void onFailure(Throwable t) {
        System.err.println("未捕获的异常：" + t.getMessage());
    }
}, service);

在这个例子中，小黑创建了一个可能抛出IllegalStateException的异步任务。然后，咱们使用Futures.catching来处理这个异常。如果异常发生，Futures.catching会调用提供的函数来返回一个默认值，这样就能防止程序崩溃，并给出一个可控的结果。

异步环境中的异常管理

异常管理在异步编程中至关重要。Guava通过提供像Futures.catching这样的工具，让咱们能够更好地控制异常处理的逻辑。这不仅使代码更健壮，也提升了用户体验。

另外，值得一提的是，使用这些方法可以帮助咱们编写出更清晰、更易于维护的代码。它减少了错误处理代码的重复，并使得异步逻辑更加直观。

第6章：组合和链式异步任务

小黑现在要带大家探索Guava中的另一项强大功能：组合和链式异步任务。在实际开发中，咱们常常遇到需要顺序执行或并行执行多个异步任务的情况。Guava提供了非常便利的工具来处理这些情景，让咱们的代码变得既简洁又高效。

组合多个异步任务

想象一下，如果咱们有两个独立的异步任务，需要在它们都完成后才能进行下一步。Guava的Futures.allAsList或者Futures.successfulAsList就是为这种场景设计的。这些方法允许咱们将多个ListenableFuture实例组合成一个，当所有的Future都完成时，组合后的Future也会完成。

来看看这个例子：

ListenableFuture<String> future1 = service.submit(() -> {
    // 模拟异步操作
    Thread.sleep(1000);
    return "任务1完成";
});

ListenableFuture<String> future2 = service.submit(() -> {
    // 模拟另一个异步操作
    Thread.sleep(1500);
    return "任务2完成";
});

// 将两个Future组合成一个
ListenableFuture<List<String>> allFutures = Futures.allAsList(future1, future2);

Futures.addCallback(allFutures, new FutureCallback<List<String>>() {
    @Override
    public void onSuccess(List<String> result) {
        // 当所有任务都成功完成后，这里会被调用
        result.forEach(System.out::println);
    }

    @Override
    public void onFailure(Throwable thrown) {
        // 如果任一任务失败，这里会被调用
        thrown.printStackTrace();
    }
}, service);

在这个例子中，小黑创建了两个异步任务，然后使用Futures.allAsList将它们组合在一起。这样，当所有任务都完成时，咱们就可以获取它们的结果了。

链式调用异步任务

另一个常见的需求是链式调用异步任务。比如，第一个任务完成后，它的输出将作为第二个任务的输入。Guava的Futures.transform方法在这里又派上用场了。

看看这个例子：

ListenableFuture<String> initialFuture = service.submit(() -> {
    // 模拟一个耗时的异步操作
    Thread.sleep(1000);
    return "初步处理完成";
});

Function<String, ListenableFuture<String>> followUpTask = (input) -> service.submit(() -> {
    // 使用前一个任务的结果
    return input + "，然后进行进一步处理";
});

// 将初始任务和后续任务链接起来
ListenableFuture<String> chainedFuture = Futures.transformAsync(initialFuture, followUpTask, service);

Futures.addCallback(chainedFuture, new FutureCallback<String>() {
    @Override
    public void onSuccess(String result) {
        System.out.println("链式任务的结果：" + result);
    }

    @Override
    public void onFailure(Throwable thrown) {
        thrown.printStackTrace();
    }
}, service);

在这里，小黑首先创建了一个初始任务，然后定义了一个后续任务。通过Futures.transformAsync，咱们将这两个任务链接起来，使得第一个任务的输出成为第二个任务的输入。

第7章：性能考虑和最佳实践

来到了Guava异步编程的第7章，这里小黑要和大家聊聊性能考虑和最佳实践。在使用Guava处理异步任务时，性能是个不能忽视的重点。正确地使用Guava不仅能提高代码的效率，还能避免一些常见的陷阱。

性能优化建议

  1. 合理配置线程池：在使用ListeningExecutorService时，线程池的大小和类型是影响性能的关键因素。如果线程池太小，可能会导致任务排队，影响性能；反之，线程池太大，则可能浪费资源。根据任务的类型（CPU密集型或IO密集型）和数量来合理配置线程池。

  2. 避免不必要的阻塞：虽然future.get()可以获取异步任务的结果，但它是阻塞的。在可能的情况下，使用非阻塞的方法，如回调或Futures.transform，这样可以避免阻塞主线程，提高整体性能。

  3. 减少上下文切换：过多的线程上下文切换会降低性能。如果异步任务非常短暂，考虑是否有必要使用异步，因为线程切换的开销可能比任务执行的时间还长。

Guava异步编程的最佳实践

  1. 清晰的错误处理：在异步编程中，错误处理很重要。使用Futures.catching等方法来清晰地处理异常，确保程序的健壮性。

  2. 避免回调地狱：虽然回调是异步编程的一个重要部分，但过多的嵌套回调（回调地狱）会使代码难以阅读和维护。合理地组织代码结构，尽可能使用链式调用来提高代码的可读性。

  3. 异步任务的合理拆分：将大的异步任务拆分成更小的部分，这样可以更灵活地管理任务，也更容易处理错误和异常。

通过遵循这些性能优化建议和最佳实践，咱们可以充分利用Guava的异步编程特性，编写出既高效又易于维护的代码。这样，不仅提高了程序的性能，还使代码更加优雅和健壮。

第8章：实际案例分析

走到这一章，小黑想用一个实际案例来展示Guava异步编程的应用。咱们知道，理论知识固然重要，但把知识应用到实践中去才能真正理解和掌握。这个案例将涉及Guava的几个核心特性，包括异步任务的创建、处理回调，以及异常管理。

案例背景

假设咱们正在开发一个电子商务应用，需要从多个供应商处获取商品价格。这些查询操作是独立的，并且可能会耗时，因此非常适合异步处理。

实现异步查询

首先，咱们为每个供应商创建一个异步任务：

Callable<Double> task1 = () -> queryPriceFromSupplier1();
Callable<Double> task2 = () -> queryPriceFromSupplier2();
// 可以添加更多供应商的任务

这里的queryPriceFromSupplier1和queryPriceFromSupplier2是模拟查询不同供应商价格的方法。

接下来，使用Guava的ListeningExecutorService提交这些任务，并将它们组合成一个：

ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(5));
List<ListenableFuture<Double>> priceFutures = Arrays.asList(
    service.submit(task1),
    service.submit(task2)
    // 添加更多的任务
);

ListenableFuture<List<Double>> allPrices = Futures.allAsList(priceFutures);
处理异步结果

现在，咱们需要处理这些异步任务的结果。使用Futures.addCallback来添加回调函数，处理每个任务的结果：

Futures.addCallback(allPrices, new FutureCallback<List<Double>>() {
    @Override
    public void onSuccess(List<Double> prices) {
        // 处理成功，例如显示价格或者计算平均值
        double averagePrice = calculateAverage(prices);
        System.out.println("平均价格: " + averagePrice);
    }

    @Override
    public void onFailure(Throwable thrown) {
        // 处理失败，例如记录日志或者通知用户
        System.err.println("查询价格失败: " + thrown.getMessage());
    }
}, service);

在这个例子中，咱们在所有价格查询完成后计算平均价格，并处理可能发生的异常。

第9章：总结

小黑和大家一起深入浅出地探讨了Guava异步编程的诸多方面。从基础的ListenableFuture和ListeningExecutorService的使用，到高级功能如回调、转换、异常处理，再到性能考虑和最佳实践，我们一步步揭开了Guava异步编程的神秘面纱。通过具体案例，我们也看到了Guava在实际开发中的应用和优势。

在这个过程中，咱们学习了如何更高效地管理和操作异步任务，如何优雅地处理异常，以及如何提高代码的清晰度和维护性。Guava的异步编程工具提供了强大的功能和灵活性，使得编写复杂的异步逻辑变得更加简单。

希望这些章节能帮助大家更好地理解和掌握Guava异步编程，让咱们的Java开发之路更加顺畅。记得，编程不仅仅是技术的积累，更是对知识的理解和应用。

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

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

相关文章

信号是怎么搞到电磁波上面去的呢？

信号是怎么搞到电磁波上面去的呢？

在之前的文章中&#xff0c;我们曾多次讲到电磁波的美妙&#xff0c;但是有了电磁波就可以通信了吗&#xff1f; No&#xff0c;我们要把信息加载到电磁波上&#xff0c;这个电磁波就可以作为信息的载体来工作了。可是信号是怎么加载到电磁波上的呢&#xff1f; 今天我们一起…
阅读更多...
宝塔上安装mysql遇到的问题

宝塔上安装mysql遇到的问题

宝塔上安装mysql遇到的问题 文章目录 宝塔上安装mysql遇到的问题一、下载mysql二、启动报错三、设置密码四、解决报错bash未找到命令mysql五、继续修改root密码五、宝塔中设置端口六、使用连接工具连接数据库 一、下载mysql 宝塔软件商店里下载mysql&#xff0c;然后点击启动。…
阅读更多...
SpringSecurity6 | 默认用户生成

SpringSecurity6 | 默认用户生成

SpringSecurity6 | 默认用户生成 ✅作者简介&#xff1a;大家好&#xff0c;我是Leo&#xff0c;热爱Java后端开发者&#xff0c;一个想要与大家共同进步的男人&#x1f609;&#x1f609; &#x1f34e;个人主页&#xff1a;Leo的博客 &#x1f49e;当前专栏&#xff1a; Java…
阅读更多...
(四) python门面模式

(四) python门面模式

文章目录 4.1 结构型设计模式4.1.1 简介4.1.2 常见的几种结构型设计模式 4.2 理解门面设计模式4.2.1 门面设计模式概述4.2.2 门面设计模式的作用 4.3 UML类图4.3.1 门面4.3.2 系统4.3.3 客户端 4.4 门面模式的代码实现4.4.1 场景&#xff1a;4.4.2 python实现 4.5 原理&#xf…
阅读更多...
【C++】动态内存管理——new和delete

【C++】动态内存管理——new和delete

这篇文章我们讲一下C的动态内存管理&#xff0c;从一个比较陌生的知识说起&#xff0c;我们知道&#xff0c;一个工程可以创建很多.c文件&#xff0c;我们如果定义一个全局变量&#xff0c;只要用extern声明一下&#xff0c;在每个文件都可以用。而用static修饰的全局变量只能在…
阅读更多...
Vue Computed

Vue Computed

小满&#xff0c;我的神&#xff01; 视频链接 // 只读 const plusOne computed(() > count.value 1) // 可读可写 const plusOne computed({get: () > count.value 1,set: (val) > {count.value val - 1} }, { // 用于调试onTrack(e) {debugger},onTrigger(e) …
阅读更多...
软件测试基础知识总结

软件测试基础知识总结

之前有将基础的软件测试知识做了一个总结&#xff0c;但比较潦草&#xff0c;很多内容只是一笔带过&#xff0c;快到年底了&#xff0c;自己也有个写年终知识总结文档的计划&#xff0c;就将基础的理论知识重新整理一番。 有人问我&#xff0c;这些都是能搜索到的知识&#xf…
阅读更多...
微信视频无法播放，快速进行格式转换方法

微信视频无法播放，快速进行格式转换方法

你是否遇到过这样的事情呢&#xff0c;朋友或者家人在电脑上用微信给你发的视频&#xff0c;在自己的微信上点开却无法播放。这种是什么原因造成的呢&#xff1f;是不是需要将这些无法播放的视频转换为微信支持的格式才行&#xff0c;那应该如何转换呢&#xff1f; 不要着急&a…
阅读更多...
使用 PyWebCopy 在 Python 中克隆网页

使用 PyWebCopy 在 Python 中克隆网页

更多资料获取 &#x1f4da; 个人网站&#xff1a;ipengtao.com PyWebCopy 是一个用于克隆网页内容的 Python 库&#xff0c;它允许用户从指定的 URL 复制整个网页并保存到本地。本文将介绍 PyWebCopy 的基本用法&#xff0c;以及如何克隆网页并保存网页内容到本地文件夹。 安…
阅读更多...
QTableView用代码设置选中状态

QTableView用代码设置选中状态

背景&#xff1a; 个人笔记&#xff0c;欢迎探讨。 目的是实现用代码设置表格中的选中状态&#xff0c;比如选中某个单元格&#xff0c;或某行&#xff0c;某列。实际上只要能完成选中单元格&#xff0c;行和列都是单元格的集合&#xff0c;道理一样。 QTableWidget比QTable…
阅读更多...
常用汇编指令集

常用汇编指令集

寄存器 如上是OD展示的寄存器&#xff0c;逐条说明常用的寄存器和标志位含义&#xff1a; EIP&#xff1a;寄存器指向即将要执行的指令的地址&#xff08;EIP中的地址&#xff0c;就是下一步要执行指令的地址&#xff09; ESP&#xff1a;里面的内容永远指向堆栈的最顶端 EAX&…
阅读更多...
青春挚爱-计算机

青春挚爱-计算机

为什么选择计算机&#xff1f; 看到这个问题&#xff0c;不禁把镜头遥向十几年前的某个片刻。 一、梦想的种子 首先信仰技术是从小的梦想&#xff0c;比如科学家精神之启蒙&#xff0c;比如勇敢者探索之启蒙。 为什么课本中的科学家可以做到精忠报国&#xff0c;矢志不渝&…
阅读更多...
Elasticsearch：什么是向量嵌入？

Elasticsearch：什么是向量嵌入？

向量嵌入定义 向量嵌入 (vector embeddings) 是一种将单词、句子和其他数据转换为捕获其含义和关系的数字的方法。 它们将不同的数据类型表示为多维空间中的点&#xff0c;其中相似的数据点更紧密地聚集在一起。 这些数字表示可以帮助机器更有效地理解和处理这些数据。 单词和…
阅读更多...
云原生的 CI/CD 框架tekton - Trigger（二）

云原生的 CI/CD 框架tekton - Trigger（二）

上一篇为大家详细介绍了tekton - pipeline&#xff0c;由于里面涉及到的概念比较多&#xff0c;因此需要好好消化下。同样&#xff0c;今天在特别为大家分享下tekton - Trigger以及案例演示&#xff0c;希望可以给大家提供一种思路哈。 文章目录 1. Tekton Trigger2. 工作流程3…
阅读更多...
【计算机系统基石与Linux进程管理深度解析】

【计算机系统基石与Linux进程管理深度解析】

​​​​​​​ 【本节重点】 认识冯诺依曼系统 操作系统概念与定位 深入理解进程概念&#xff0c;了解PCB 学习进程状态&#xff0c;学会创建进程&#xff0c;掌握僵尸进程和孤儿进程&#xff0c;及其形成原因和危害 1.冯诺依曼体系结构 我们常见的计算机&#xff0c;如…
阅读更多...
App内存优化

App内存优化

一、内存优化介绍 1.背景介绍 内存是大问题但缺乏关注压实骆驼的最后一个稻草&#xff08;堆栈溢出&#xff09; 2.内存问题 内存抖动&#xff1a;锯齿状、GC导致卡顿内存泄露&#xff1a;可用内存减少、频繁GC内存溢出&#xff1a;OOM&#xff0c;程序异常 二、优化工具选…
阅读更多...
【C语言】函数递归详解（二）

【C语言】函数递归详解（二）

前言 在上一篇博客函数递归详解&#xff08;一&#xff09;中讲解了什么是递归&#xff0c;递归的思想及限制条件以及两个递归的例子&#xff0c;这一篇博客将讲解递归与迭代的关系。 递归与迭代 递归是一种很好的编程技巧&#xff0c;但是同很多技巧一样也是可能被误用的&…
阅读更多...
api 网关

api 网关

API网关 什么是网关&#xff1f; 微服务背景下&#xff0c;一个系统被拆分为多个服务&#xff0c;但是像安全认证&#xff0c;流量控制&#xff0c;日志&#xff0c;监控等功能是每个服务都需要的&#xff0c;没有网关的话&#xff0c;我们就需要在每个服务中单独实现&#x…
阅读更多...
2023年【T电梯修理】考试总结及T电梯修理证考试

2023年【T电梯修理】考试总结及T电梯修理证考试

题库来源&#xff1a;安全生产模拟考试一点通公众号小程序 T电梯修理考试总结考前必练&#xff01;安全生产模拟考试一点通每个月更新T电梯修理证考试题目及答案&#xff01;多做几遍&#xff0c;其实通过T电梯修理证考试很简单。 1、【多选题】《特种设备安全法》规定&#x…
阅读更多...
【2】PyQt创建窗口

【2】PyQt创建窗口

1. 第一个PyQt窗口 from PyQt5.QtWidgets import QApplication,QWidget import sys# 1.创建应用程序 app QApplication(sys.argv)# 2.创建窗口 w QWidget()# 3.显示窗口 w.show()# 4.等待窗口停止 sys.exit(app.exec()) 执行代码,就会显示PyQt窗口: 2. PyQt模块简介 PyQt中…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023