CompletableFuture 异步编排如何使用？

news2024/11/25 10:13:52

概述：

在做提交订单功能时，我们需要处理的事务很多，如：修改库存、计算优惠促销信息、会员积分加减、线上支付、金额计算、生成产品订单、生成财务信息、删除购物车等等。如果这些功能全部串行化处理，会发费很长的时间，特别是在大量数据并发的时候，有可能导致服务器崩溃等各种异常。

CompletableFuture 异步编排的出现，完全解决了上面的情况，这些功能基本可以并行处理。那么什么是CompletableFuture 异步编排？

  • CompletableFuture 异步编排是一个 Java 8 引入的异步编程工具，它提供了一种方便的方式来处理异步任务。

  • 异步编排是指将多个异步任务按照一定的顺序或依赖关系组合起来执行，以实现更复杂的业务逻辑。

  • CompletableFuture 类实现了 Future 接口，所以你还是可以像以前一样通过get方法阻塞或
    者轮询的方式获得结果，但是这种方式不推荐使用。

  • CompletableFuture 和 FutureTask 同属于 Future 接口的实现类，都可以获取线程的执行结果。

如图：
在这里插入图片描述

在编排异步操作时，CompletableFuture 提供了一些方法，例如 thenApply、thenAccept、thenRun 等，这些方法允许您在异步操作完成后执行一些操作。下面重点讲述这些方法。

一、创建异步对象

1 基本方法

CompletableFuture 提供了四个静态方法来创建一个异步操作。

static CompletableFuture<Void> runAsync(Runnable runnable)
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier， Executorexecutor)

1、runXxxx 都是没有返回结果的，supplyXxx 都是可以获取返回结果的
2、可以传入自定义的线程池，否则就用默认的线程池；

2 示例：

  public static void runAsync() {
        System.out.println("runAsync....start....");
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("计算结果：" + i);
        }, executorService);
        System.out.println("runAsync....end....");
    }

二、计算完成时回调方法

1 基本方法

public CompletableFuture<T> whenComplete(BiConsumer<? super T,? super Throwable> action):
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable>action);
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable>action， Executor executor):
public CompletableFuture<T> exceptionally(Function<Throwable,? extends T> fn);
  • whenComplete 可以处理正常和异常的计算结果，exceptionally 处理异常情况。
  • whenComplete 和 whenCompleteAsync 的区别：

whenComplete：是执行当前任务的线程执行继续执行 whenComplete 的任务。
whenCompleteAsync：是执行把 whenCompleteAsync 这个任务继续提交给线程池来进行执行

方法不以 Async 结尾，意味着 Action 使用相同的线程执行，而 Async 可能会使用其他线程
执行（如果是使用相同的线程池，也可能会被同一个线程选中执行）

2 示例

public static void suplyAsync() {
        try {
            System.out.println("suplyAsync....start....");
            CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
                System.out.println("当前线程：" + Thread.currentThread().getId());
                int i = 10 / 0;
                System.out.println("计算结果：" + i);
                return i;
            }, executorService).whenComplete((res, err) -> {
                System.out.println("异步任务完成了..结果.." + res);
                System.out.println("异步任务完成了..异常.." + err);
            }).exceptionally(throwable -> {
                System.out.println("发生了异常.返回默认值....");
                return 10;
            });
            System.out.println("最终结果：" + future.get());
            System.out.println("suplyAsync....end....");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

三、handle 方法

1 基本方法

public <U> Completionstage<U> handle(BiFunction<? super T, Throwable,? extends U> fn);
public <U> Completionstage<U> handleAsync(BiFunction<? super T, Throwable, ? extends U>fn);
public <U> CompletionStage<U> handleAsync(BiFunction<? super T, Throwable, ? extends U>
fn,Executor executor);

和 complete 一样，可对结果做最后的处理（可处理异常），可改变返回值。

2 示例

//完成后的处理
public static void suplyAsyncHandler() {
    try {
        System.out.println("suplyAsyncHandler....start....");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("计算结果：" + i);
            return i;
        }, executorService).handle((res, err) -> {
            if(res != null){
                System.out.println("res：" + res);
                return res * 2;
            }
            if (err != null){
                System.out.println("err：" + err);
                return 0;
            }
            return res;
        });
        System.out.println("最终结果====" + future.get());
        System.out.println("suplyAsyncHandler....end....");
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

四、线程串行化方法

1 基本方法

public <U> CompletableFuture<u> thenApply(Function<? super T,? extends U> fn)
public <U> CompletableFuture<u> thenApplyAsync(Function<? super T,? extends U> fn)
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn,Executor executor)

public CompletionStage<Void> thenAccept(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action,Executorexecutor);

public CompletionStage<Void> thenRun(Runnable action);
public Completionstage<Void> thenRunAsync(Runnable action);
public CompletionStage<Void> thenRunAsync(Runnable action,Executor executor);
  • thenApply 方法：当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前
    任务的返回值。
  • thenAccept 方法：消费处理结果。接收任务的处理结果，并消费处理，无返回结果。
  • thenRun 方法：只要上面的任务执行完成，就开始执行 thenRun，只是处理完任务后，执行
    thenRun 的后续操作
  • 带有 Async 默认是异步执行的。同之前。

以上都要前置任务成功完成。

Function<? super T,? extends U>
T：上一个任务返回结果的类型
U：当前任务的返回值类型

2 示例

//---多个任务串行执行-----------------------------------------------------
    //ThenApplyAsync 可以获取上次的结果，有返回值
    public static void suplyAsyncThenApplyAsync() {
        try {
            System.out.println("suplyAsyncThenRun....start....");
            CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
                System.out.println("当前线程：" + Thread.currentThread().getId());
                int i = 10 / 2;
                System.out.println("计算结果：" + i);
                return i;
            }, executorService).thenApplyAsync((res) -> {
                System.out.println("任务1的结果是...." + res);
                System.out.println("启动任务2..........");
                return res;
            }, executorService);
            System.out.println("最终结果是：" + future);
            System.out.println("suplyAsyncThenRun....end....");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }


    //thenAcceptAsync 可以获取上次的结果，没返回值
    public static void suplyAsyncThenAcceptAsync() {
        try {
            System.out.println("suplyAsyncThenRun....start....");
            CompletableFuture.supplyAsync(() -> {
                System.out.println("当前线程：" + Thread.currentThread().getId());
                int i = 10 / 2;
                System.out.println("计算结果：" + i);
                return i;
            }, executorService).thenAcceptAsync((res) -> {
                System.out.println("任务1的结果是...." + res);
                System.out.println("启动任务2..........");
            }, executorService);
            System.out.println("suplyAsyncThenRun....end....");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    //thenRunAsync 不能获取上次任务的结果，没返回值
    public static void suplyAsyncThenRun() {
        try {
            System.out.println("suplyAsyncThenRun....start....");
            CompletableFuture.supplyAsync(() -> {
                System.out.println("当前线程：" + Thread.currentThread().getId());
                int i = 10 / 2;
                System.out.println("计算结果：" + i);
                return i;
            }, executorService).thenRunAsync(() -> {
                System.out.println("启动任务2..........");
            }, executorService);
            System.out.println("suplyAsyncThenRun....end....");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

五、两任务组合 - 都要完成

1 基本介绍

public <U,V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other ,BiFunction<? super T,? super U,? extends V> fn);
public <U,V> CompletableFuture<v> thenCombineAsync(CompletionStage<? extends U> otherBiFunction<? super T,? super u,? extends V> fn);
public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other ,BiFunction<? super T,? super U,? extends V> fn, Executor executor);

public <U> CompletableFuture<Void> thenAcceptBoth(Completionstage<? extends U> other .BiConsumer<? super T，? super U> action);
public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other .BiConsumer<? super T, ? super U> action) ;
public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other ,BiConsumer<? super t. ? super Us action. Executor executor):

public CompletableFuture<Void> runAfterBoth(CompletionStage<?> other.Runnable action);
public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other .Runnable action):
public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> otherRunnable action,
Executor executor  ;

两个任务必须都完成，触发该任务。

  • thenCombine：组合两个 future，获取两个 future 的返回结果，并返回当前任务的返回值
  • thenAcceptBoth：组合两个 future，获取两个 future 任务的返回结果，然后处理任务，没有
    返回值。
  • runAfterBoth：组合两个 future，不需要获取 future 的结果，只需两个 future 处理完任务后，
    处理该任务。

2 示例

//---任务组合-----------------------------------------------------
public static void thenCombineAsync() throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程1：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("计算结果1：" + i);
            return i;
        }, executorService);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程2：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("计算结果2：" + i);
            return i;
        }, executorService);

        CompletableFuture<Integer> future3 = future1.thenCombineAsync(future2, (res1, res2) -> {
            System.out.println("线程1结果....." + res1);
            System.out.println("线程2结果....." + res2);
            System.out.println("线程3开始.....");
            return res1 + res2;
        }, executorService);

        System.out.println("线程3的结果是...." + future3.get());

    }

    public static void thenAcceptBothAsync() {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程1：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("计算结果1：" + i);
            return i;
        }, executorService);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程2：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("计算结果2：" + i);
            return i;
        }, executorService);

        future1.thenAcceptBothAsync(future2, (res1, res2)-> {
            System.out.println("线程1结果....." + res1);
            System.out.println("线程2结果....." + res2);
            System.out.println("线程3开始.....");
        }, executorService);

    }

    public static void runAfterBothAsync() {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程1：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("计算结果1：" + i);
            return i;
        }, executorService);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程2：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("计算结果2：" + i);
            return i;
        }, executorService);

        future1.runAfterBothAsync(future2, ()-> {
            System.out.println("线程3开始.....");
        }, executorService);

    }

六、两任务组合 - 一个完成

1 函数介绍

public <U> CompletableFuture<u> applyToEither(
CompletionStage<? extends T> other , Function<? super T, U> fn);
public <U> CompletableFuture<U> applyToEitherAsync(
CompletionStage<? extends T> other , Function<? super T, U> fn);
public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other , Function<? super T, U> fn,Executor executor):

public CompletableFuture<Void> acceptEither(CompletionStage<? extends T> other , Consumer<? super T> action);
public CompletableFuture<Void> acceptEitherAsync
CompletionStage<? extends T> other, Consumer<? super T> action);
public CompletableFuture<void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action,Executor executor ;

public CompletableFuture<Void> runAfterEither (CompletionStage<?> other ,Runnable action);
public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other ,Runnable action);
public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other ,Runnable action,
Executor executor);

当两个任务中，任意一个 future 任务完成的时候，执行任务。

  • applyToEither：两个任务有一个执行完成，获取它的返回值，处理任务并有新的返回值。
  • acceptEither：两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值。
  • runAfterEither：两个任务有一个执行完成，不需要获取 future 的结果，处理任务，也没有返
    回值。

2 示例

 //---任务组合--一个都完成---------------------------------------------------
    public static void applyToEitherAsync() throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程1：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("计算结果1：" + i);
            return i;
        }, executorService);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程2：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("计算结果2：" + i);
            return i;
        }, executorService);

        CompletableFuture<Integer> future3 = future1.applyToEitherAsync(future2, (res1) -> {
            System.out.println("线程1结果....." + res1);
            System.out.println("线程3开始.....");
            return res1;
        }, executorService);

        System.out.println("线程3的结果是...." + future3.get());

    }

    public static void acceptEitherAsync() {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程1：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("计算结果1：" + i);
            return i;
        }, executorService);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程2：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("计算结果2：" + i);
            return i;
        }, executorService);

        future1.acceptEitherAsync(future2, (res1)-> {
            System.out.println("线程1结果....." + res1);
            System.out.println("线程3开始.....");
        }, executorService);

    }

    public static void runAfterEitherAsync() {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程1：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("计算结果1：" + i);
            return i;
        }, executorService);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程2：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("计算结果2：" + i);
            return i;
        }, executorService);

        future1.runAfterEitherAsync(future2, ()-> {
            System.out.println("线程3开始.....");
        }, executorService);

    }

七、多任务组合

1 函数介绍

public static CompletableFuture<Void> allof(CompletableFuture<?>... cfs);
public static CompletableFuture<0bject> anyof(CompletableFuture<?>... cfs);
  • allof: 等待所有任务完成
  • anyof: 只要有一个任务完成

2 示例

 public static void allOf() throws ExecutionException, InterruptedException {
	CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1执行");
            return 10 / 2;
        }, executor);
        CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2执行");
            return "hello";
        }, executor);
        CompletableFuture<String> future03 = future01.thenCombineAsync(future02,
                (result1, result2) -> {
                    System.out.println("任务3执行");
                    System.out.println("任务1返回值：" + result1);
                    System.out.println("任务2返回值：" + result2);
                    return "任务3返回值";
                }, executor);
        System.out.println(future03.get());


        CompletableFuture<Void> allOf = CompletableFuture.allOf(future01, future02, future03);
        allOf.get();// 阻塞等待所有任务完成
  }


public static void anyOf() throws ExecutionException, InterruptedException {
	CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1执行");
            return 10 / 2;
        }, executor);
        CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2执行");
            return "hello";
        }, executor);
        CompletableFuture<String> future03 = future01.thenCombineAsync(future02,
                (result1, result2) -> {
                    System.out.println("任务3执行");
                    System.out.println("任务1返回值：" + result1);
                    System.out.println("任务2返回值：" + result2);
                    return "任务3返回值";
                }, executor);
        System.out.println(future03.get());


        CompletableFuture<Void> anyOf= CompletableFuture.allOf(future01, future02, future03);
        anyOf.get();// 阻塞等待任一任务完成，返回值是执行成功的任务返回值
  }

八、源码下载

https://gitee.com/charlinchenlin/koo-erp

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

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

相关文章

【盘点】界面控件DevExpress WPF的几大应用程序主题

【盘点】界面控件DevExpress WPF的几大应用程序主题

DevExpress WPF控件包含了50个应用程序主题和40个调色板&#xff0c;用户可以在发布应用程序是指定主题&#xff0c;或允许最终用户动态修改WPF应用程序的外观和样式&#xff0c;其中主题带有调色板&#xff0c;可以进一步个性化您的UI&#xff01; PS&#xff1a;DevExpress …
阅读更多...
oracle WAITED TOO LONG FOR A ROW CACHE ENQUEUE LOCK问题分析

oracle WAITED TOO LONG FOR A ROW CACHE ENQUEUE LOCK问题分析

服务概述 财务系统出现业务卡顿&#xff0c;数据库实例2遇到>>> WAITED TOO LONG FOR A ROW CACHE ENQUEUE LOCK! <<<错误导致业务HANG住。 对此HANG的原因进行分析&#xff1a; 故障发生时&#xff0c;未有主机监控数据&#xff0c;从可以获取的数据库A…
阅读更多...
c++ 11标准模板（STL） std::map(三）

c++ 11标准模板（STL） std::map(三）

定义于头文件<map> template< class Key, class T, class Compare std::less<Key>, class Allocator std::allocator<std::pair<const Key, T> > > class map;(1)namespace pmr { template <class Key, class T, clas…
阅读更多...
使用Linkage Mapper工进行物种分布建模的步骤详解（含实际案例分析）

使用Linkage Mapper工进行物种分布建模的步骤详解（含实际案例分析）

✅创作者：陈书予 🎉个人主页：陈书予的个人主页 🍁陈书予的个人社区，欢迎你的加入: 陈书予的社区 🌟专栏地址: Linkage Mapper解密数字世界链接 文章目录 引言：一、介绍二、数据准备2.1 物种分布数据获取2.2 环境变量数据获取2.3 数据预处理
阅读更多...
【拼多多API 开发系列】百亿补贴商品详情接口，代码封装

【拼多多API 开发系列】百亿补贴商品详情接口，代码封装

为了进行电商平台 PDD 的API开发&#xff0c;首先我们需要做下面几件事情。 1&#xff09;开发者注册一个账号 2&#xff09;然后为每个 PDD 应用注册一个应用程序键&#xff08;App Key) 。 3&#xff09;下载 PDD API的SDK并掌握基本的API基础知识和调用 4&#xff09;利用SD…
阅读更多...
CSS布局：浮动与绝对定位的异同点

CSS布局：浮动与绝对定位的异同点

CSS布局&#xff1a;浮动与绝对定位的异同点_cherry_vincent的博客-CSDN博客 浮动 ( float ) 和绝对定位 ( position:absolute ) 相同点&#xff1a; &#xff08;1&#xff09;都是漂起来( 离开原来的位置 ) &#xff08;2&#xff09;并且都不占着原来的位置 &#xff08;3…
阅读更多...
Flutter 笔记 | Flutter 布局组件

Flutter 笔记 | Flutter 布局组件

布局类组件都会包含一个或多个子组件&#xff0c;布局类组件都是直接或间接继承SingleChildRenderObjectWidget 和MultiChildRenderObjectWidget的Widget&#xff0c;它们一般都会有一个child或children属性用于接收子 Widget。 不同的布局类组件对子组件排列&#xff08;layo…
阅读更多...
企业级WordPress开发 – 创建企业级网站的优秀提示

企业级WordPress开发 – 创建企业级网站的优秀提示

目录 “企业级”是什么意思&#xff1f; 使用WordPress创建企业级网站有什么好处&#xff1f; 使用 WordPress 进行企业开发的主要好处 WordPress 可扩展、灵活且价格合理 WordPress 提供响应式 Web 开发 WordPress 提供了巨大的可扩展性 不断更新使 WordPress 万无一…
阅读更多...
JAVA-创建PDF文档

JAVA-创建PDF文档

目录 一、前期准备 1、中文字体文件 2、maven依赖 二、创建PDF文档方法 三、通过可填充PDF模板将业务参数进行填充 1、 设置可填充的PDF表单 2、代码开干&#xff0c;代码填充可编辑PDF并另存文件 一、前期准备 1、中文字体文件 本演示使用的是iText 7版本&#xff0c…
阅读更多...
Jeddak-DPSQL 首次开源！基于差分隐私的 SQL 代理保护能力

Jeddak-DPSQL 首次开源！基于差分隐私的 SQL 代理保护能力

动手点关注 干货不迷路 ‍ ‍1. 背景 火山引擎对于用户敏感数据尤为重视&#xff0c;在火山引擎提供的数据分析产品中&#xff0c;广泛采用差分隐私技术对用户敏感信息进行保护。此类数据产品通常构建于 ClickHouse 等数据引擎之上&#xff0c;以 SQL 查询方式来执行计算逻辑&a…
阅读更多...
【计算机网络复习】第六章 关系数据理论 1

【计算机网络复习】第六章 关系数据理论 1

关系模式的设计 按照一定的原则从数量众多而又相互关联的数据中&#xff0c;构造出一组既能较好地反映现实世界&#xff0c;而又有良好的操作性能的关系模式 ●冗余度高 ●修改困难 ●插入问题 ●删除问题 ★产生问题的原因 属性间约束关系&#xff08;即数据间的依赖关系&…
阅读更多...
【JavaSE】Java基础语法(十)：构造方法

【JavaSE】Java基础语法(十)：构造方法

文章目录 ⛄1. 构造方法的格式和执行时机⛄2. 构造方法的作用⛄3. 构造方法的特点⛄4. 构造方法的注意事项⛄5. 构造方法为什么不能被重写 在面向对象编程的思想中&#xff0c;构造方法&#xff08;Constructor&#xff09;是一个特殊的函数&#xff0c;用于创建和初始化类的对…
阅读更多...
“数字”厨电成新宠？“传统”厨电如何凭实力年销破百亿？｜厨房电器SMI社媒心智品牌榜

“数字”厨电成新宠？“传统”厨电如何凭实力年销破百亿？｜厨房电器SMI社媒心智品牌榜

Social Power 核心解读 AI加持&#xff0c;数字厨电新物种持续走红 传统厨电发力社媒&#xff0c;“有范儿”实力吸睛 4月中下旬的“魔都”可谓热闹非凡&#xff0c;上海车展喧嚣未落&#xff0c;隔壁2023AWE&#xff08;中国家电及消费电子博览会&#xff09;的群雄逐鹿紧随…
阅读更多...
Electron 小白介绍，你能看懂吗？

Electron 小白介绍，你能看懂吗？

目录 前言一、Electron是什么1.官网介绍2.小白介绍 二、Electron开发了哪些应用三、Electron的优势在哪里1.优势2.带给我们什么优势 四、Electron如何学习1.前置知识2.学习建议 五、Electron的乐趣总结 前言 在最近的学习中&#xff0c;我接触了 Electron 这个前端框架&#x…
阅读更多...
总结加载Shellcode的各种方式(更新中！)

总结加载Shellcode的各种方式(更新中！)

1.内联汇编加载 使用内联汇编只能加载32位程序的ShellCode&#xff0c;因为64位程序不支持写内联汇编 #pragma comment(linker, "/section:.data,RWE") //将data段的内存设置成可读可写可执行 #include <Windows.h>//ShellCode部分 unsigned char buf[] &qu…
阅读更多...
Hadoop的基础操作

Hadoop的基础操作

Hadoop的基础操作 HDFS是Hadoop的分布式文件框架&#xff0c;它的实际目标是能够在普通的硬件上运行&#xff0c;并且能够处理大量的数据。HDFS采用主从架构&#xff0c;其中由一个NameNode和多个DataNode NameNode负责管理文件系统的命名空间和客户端的访问DataNode负责存储实…
阅读更多...
企业为什么要做数字化转型，应该如何进行转型？

企业为什么要做数字化转型，应该如何进行转型？

企业需要数字化转型才能在当今快速发展的商业环境中保持竞争力和相关性。数字化转型涉及利用数字技术和战略从根本上改变企业的运营方式、为客户创造价值并实现他们的目标。以下是企业进行数字化转型的一些关键原因&#xff1a; 提高运营效率&#xff1a;数字技术可实现自动化、…
阅读更多...
如何使用ArcGIS标注上下标

如何使用ArcGIS标注上下标

&#xff08;本文首发于“水经注GIS”公号&#xff0c;关注公号免费领取地图数据&#xff09; 在某些情况下除了需要普通的标注之外还需要上下标注&#xff0c;对于这一需求&#xff0c;ArcGIS是支持的&#xff0c;这里为大家介绍一下ArcGIS标注上下标的方法&#xff0c;希望能…
阅读更多...
初阶数据结构之栈的实现（五）

初阶数据结构之栈的实现（五）

文章目录 &#x1f60f;专栏导读&#x1f916;文章导读&#x1f640;什么是栈&#xff1f;&#x1f640;画图描述 &#x1f633;栈的代码实现及其各类讲解&#x1f633;栈的初始化代码实现及其讲解&#x1f633;栈的初始化 &#x1f633;栈的销毁代码实现及其讲解&#x1f633;…
阅读更多...
【面试题】2023vue面试题

【面试题】2023vue面试题

大厂面试题分享 面试题库 前后端面试题库 &#xff08;面试必备&#xff09; 推荐&#xff1a;★★★★★ 地址&#xff1a;前端面试题库 web前端面试题库 VS java后端面试题库大全 1、说说你对 SPA 单页面的理解&#xff0c;它的优缺点分别是什么&#xff1f; SPA&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023