鸿蒙开发- 线程（一）

原创 已于 2022-01-24 14:31:10 修改 · 600 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#harmonyos #java #华为

于 2022-01-24 14:15:32 首次发布
<?xml version="1.0" encoding="utf-8"?>
<!--
 Copyright (c) 2021 Huawei Device Co., Ltd.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 -->
<DirectionalLayout
    xmlns:ohos="http://schemas.huawei.com/res/ohos"
    ohos:height="match_parent"
    ohos:width="match_parent"
    ohos:alignment="horizontal_center"
    ohos:orientation="vertical"
    ohos:padding="5vp">

    <Button
        ohos:id="$+id:sync_dispatch_button"
        ohos:height="match_content"
        ohos:width="300vp"
        ohos:background_element="$graphic:button_bg"
        ohos:padding="5vp"
        ohos:text="$string:sync_dispatch"
        ohos:text_alignment="center"
        ohos:text_size="18fp"
        ohos:top_margin="50vp"/>

    <Button
        ohos:id="$+id:async_dispatch_button"
        ohos:height="match_content"
        ohos:width="300vp"
        ohos:background_element="$graphic:button_bg"
        ohos:padding="5vp"
        ohos:text="$string:async_dispatch"
        ohos:text_alignment="center"
        ohos:text_size="18fp"
        ohos:top_margin="10vp"/>

    <Button
        ohos:id="$+id:delay_dispatch_button"
        ohos:height="match_content"
        ohos:width="300vp"
        ohos:background_element="$graphic:button_bg"
        ohos:padding="5vp"
        ohos:text="$string:delay_dispatch"
        ohos:text_alignment="center"
        ohos:text_size="18fp"
        ohos:top_margin="10vp"/>

    <Button
        ohos:id="$+id:group_dispatch_button"
        ohos:height="match_content"
        ohos:width="300vp"
        ohos:background_element="$graphic:button_bg"
        ohos:padding="5vp"
        ohos:text="$string:dispatch_group"
        ohos:text_alignment="center"
        ohos:text_size="18fp"
        ohos:top_margin="10vp"/>

    <Button
        ohos:id="$+id:revoke_task_button"
        ohos:height="match_content"
        ohos:width="300vp"
        ohos:background_element="$graphic:button_bg"
        ohos:padding="5vp"
        ohos:text="$string:revoke_task"
        ohos:text_alignment="center"
        ohos:text_size="18fp"
        ohos:top_margin="10vp"/>

    <Button
        ohos:id="$+id:sync_barrier_button"
        ohos:height="match_content"
        ohos:width="300vp"
        ohos:background_element="$graphic:button_bg"
        ohos:padding="5vp"
        ohos:text="$string:sync_dispatch_barrier"
        ohos:text_alignment="center"
        ohos:text_size="18fp"
        ohos:top_margin="10vp"/>

    <Button
        ohos:id="$+id:async_barrier_button"
        ohos:height="match_content"
        ohos:width="300vp"
        ohos:background_element="$graphic:button_bg"
        ohos:padding="5vp"
        ohos:text="$string:async_dispatch_barrier"
        ohos:text_alignment="center"
        ohos:text_size="18fp"
        ohos:top_margin="10vp"/>

    <Button
        ohos:id="$+id:apply_dispatch_button"
        ohos:height="match_content"
        ohos:width="300vp"
        ohos:background_element="$graphic:button_bg"
        ohos:padding="5vp"
        ohos:text="$string:apply_Dispatch"
        ohos:text_alignment="center"
        ohos:text_size="18fp"
        ohos:top_margin="10vp"/>

    <Text
        ohos:id="$+id:result_text"
        ohos:height="150vp"
        ohos:width="match_parent"
        ohos:background_element="$graphic:common_bg"
        ohos:margin="20vp"
        ohos:multiple_lines="true"
        ohos:padding="10vp"
        ohos:text_size="16fp"/>
</DirectionalLayout>

private void initComponents() {
        Component syncDispatchButton = findComponentById(ResourceTable.Id_sync_dispatch_button);
        Component asyncDispatchButton = findComponentById(ResourceTable.Id_async_dispatch_button);
        Component delayDispatchButton = findComponentById(ResourceTable.Id_delay_dispatch_button);
        Component groupDispatchButton = findComponentById(ResourceTable.Id_group_dispatch_button);
        syncDispatchButton.setClickedListener(this::syncTask);
        asyncDispatchButton.setClickedListener(this::asyncTask);
        delayDispatchButton.setClickedListener(this::delayTask);
        groupDispatchButton.setClickedListener(this::groupTask);
        resultText = (Text) findComponentById(ResourceTable.Id_result_text);
        Component revokeTaskButton = findComponentById(ResourceTable.Id_revoke_task_button);
        Component syncBarrierButton = findComponentById(ResourceTable.Id_sync_barrier_button);
        Component asyncBarrierButton = findComponentById(ResourceTable.Id_async_barrier_button);
        Component applyDispatchButton = findComponentById(ResourceTable.Id_apply_dispatch_button);
        revokeTaskButton.setClickedListener(this::postTaskAndRevoke);
        syncBarrierButton.setClickedListener(this::syncBarrier);
        asyncBarrierButton.setClickedListener(this::asyncBarrier);
        applyDispatchButton.setClickedListener(this::applyDispatchTask);
    }

private void syncTask(Component component) {
        StringBuffer stringBuffer = new StringBuffer();
        TaskDispatcher globalTaskDispatcher = getGlobalTaskDispatcher(TaskPriority.DEFAULT);
        globalTaskDispatcher.syncDispatch(() -> stringBuffer.append("Sync task1 run").append(System.lineSeparator())
        );
        stringBuffer.append("After sync task1").append(System.lineSeparator());
        globalTaskDispatcher.syncDispatch(() -> stringBuffer.append("Sync task2 run").append(System.lineSeparator()));
        stringBuffer.append("After sync task2").append(System.lineSeparator());
        resultText.setText(stringBuffer.toString());
    }

    private void asyncTask(Component component) {
        StringBuffer stringBuffer = new StringBuffer();
        TaskDispatcher globalTaskDispatcher = getGlobalTaskDispatcher(TaskPriority.DEFAULT);
        globalTaskDispatcher.asyncDispatch(() -> {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                HiLog.error(LABEL_LOG, "%{public}s", "AsyncDispatch InterruptedException");
            }
            stringBuffer.append("Async task1 run").append(System.lineSeparator());
            handler.postSyncTask(() -> resultText.setText(stringBuffer.toString()));
        });
        stringBuffer.append("After async task1").append(System.lineSeparator());
        globalTaskDispatcher.asyncDispatch(() -> {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                HiLog.error(LABEL_LOG, "%{public}s", "AsyncDispatch InterruptedException");
            }
            stringBuffer.append("Async task2 run").append(System.lineSeparator());
            handler.postSyncTask(() -> resultText.setText(stringBuffer.toString()));
        });
        stringBuffer.append("After async task2").append(System.lineSeparator());
        resultText.setText(stringBuffer.toString());
    }

    private void delayTask(Component component) {
        StringBuffer stringBuffer = new StringBuffer();
        TaskDispatcher globalTaskDispatcher = getGlobalTaskDispatcher(TaskPriority.DEFAULT);
        final long callTime = System.currentTimeMillis();
        globalTaskDispatcher.delayDispatch(() -> {
            stringBuffer.append("DelayDispatch task1 run").append(System.lineSeparator());
            final long actualDelayMs = System.currentTimeMillis() - callTime;
            stringBuffer.append("ActualDelayTime >= delayTime : ").append((actualDelayMs >= DELAY_TIME));
            handler.postSyncTask(() -> resultText.setText(stringBuffer.toString()));
        }, DELAY_TIME);
        stringBuffer.append("After delayDispatch task1").append(System.lineSeparator());
        resultText.setText(stringBuffer.toString());
    }

    private void groupTask(Component component) {
        StringBuffer stringBuffer = new StringBuffer();
        TaskDispatcher dispatcher = createParallelTaskDispatcher("", TaskPriority.DEFAULT);
        Group group = dispatcher.createDispatchGroup();
        dispatcher.asyncGroupDispatch(group, () -> {
            stringBuffer.append("GroupTask1 is running").append(System.lineSeparator());
            handler.postSyncTask(() -> resultText.setText(stringBuffer.toString()));
        });
        dispatcher.asyncGroupDispatch(group, () -> {
            stringBuffer.append("GroupTask2 is running").append(System.lineSeparator());
            handler.postSyncTask(() -> resultText.setText(stringBuffer.toString()));
        });
        dispatcher.groupDispatchNotify(group, () -> stringBuffer.append(
            "This task running after all tasks in the group are completed").append(System.lineSeparator()));
        resultText.setText(stringBuffer.toString());
    }

    private void postTaskAndRevoke(Component component) {
        StringBuffer stringBuffer = new StringBuffer();
        TaskDispatcher dispatcher = getUITaskDispatcher();
        Revocable revocable = dispatcher.delayDispatch(() -> {
            stringBuffer.append("Delay dispatch").append(System.lineSeparator());
            handler.postSyncTask(() -> resultText.setText(stringBuffer.toString()));
        }, 50);
        boolean revoked = revocable.revoke();
        stringBuffer.append("Revoke result :").append(revoked);
        resultText.setText(stringBuffer.toString());
    }

    private void syncBarrier(Component component) {
        StringBuffer stringBuffer = new StringBuffer();
        TaskDispatcher dispatcher = createParallelTaskDispatcher("SyncBarrierDispatcher", TaskPriority.DEFAULT);
        Group group = dispatcher.createDispatchGroup();
        dispatcher.asyncGroupDispatch(group, () -> stringBuffer.append("Task1 is running").append(System.lineSeparator()));
        dispatcher.asyncGroupDispatch(group, () -> stringBuffer.append("Task2 is running").append(System.lineSeparator()));
        dispatcher.syncDispatchBarrier(() -> stringBuffer.append("Barrier").append(System.lineSeparator()));
        stringBuffer.append("After syncDispatchBarrier").append(System.lineSeparator());
        resultText.setText(stringBuffer.toString());
    }

    private void asyncBarrier(Component component) {
        StringBuffer stringBuffer = new StringBuffer();
        TaskDispatcher dispatcher = createParallelTaskDispatcher("AsyncBarrierDispatcher", TaskPriority.DEFAULT);
        Group group = dispatcher.createDispatchGroup();
        dispatcher.asyncGroupDispatch(group, () -> {
            stringBuffer.append("Task1 is running").append(System.lineSeparator());
            handler.postSyncTask(() -> resultText.setText(stringBuffer.toString()));
        });
        dispatcher.asyncGroupDispatch(group, () -> {
            stringBuffer.append("Task2 is running").append(System.lineSeparator());
            handler.postSyncTask(() -> resultText.setText(stringBuffer.toString()));
        });
        dispatcher.asyncDispatchBarrier(() -> {
            stringBuffer.append("Barrier").append(System.lineSeparator());
            handler.postSyncTask(() -> resultText.setText(stringBuffer.toString()));
        });
        stringBuffer.append("After asyncDispatchBarrier").append(System.lineSeparator());
        resultText.setText(stringBuffer.toString());
    }

    private void applyDispatchTask(Component component) {
        StringBuilder stringBuilder = new StringBuilder();
        final CountDownLatch latch = new CountDownLatch(TASK_TOTAL);
        final ArrayList<Long> indexList = new ArrayList<>(TASK_TOTAL);
        TaskDispatcher globalTaskDispatcher = getGlobalTaskDispatcher(TaskPriority.DEFAULT);
        globalTaskDispatcher.applyDispatch(index -> {
            indexList.add(index);
            latch.countDown();
        }, TASK_TOTAL);
        try {
            latch.await();
        } catch (InterruptedException exception) {
            HiLog.error(LABEL_LOG, "%{public}s", "applyDispatchTask InterruptedException");
        }
        stringBuilder.append("List size matches :").append((indexList.size() == TASK_TOTAL));
        resultText.setText(stringBuilder.toString());
    }

鸿蒙多线程开发——Worker多线程
harmonyClassRoom的博客
11-09 2009
Worker主要作用是为应用程序提供一个多线程的运行环境，可满足应用程序在执行过程中与主线程分离，在后台线程中运行一个脚本进行耗时操作，极大避免类似于计算密集型或高延迟的任务阻塞主线程的运行。创建Worker的线程称为宿主线程（不一定是主线程，工作线程也支持创建Worker子线程），Worker自身的线程称为Worker子线程（或Actor线程、工作线程）。
鸿蒙开发基础 —— 多线程并发(Worker)
guangxishaoji的博客
02-25 1031
创建Worker的线程称为宿主线程（不一定是主线程，工作线程也支持创建Worker子线程），Worker自身的线程称为Worker子线程（或Actor线程、工作线程）。每个Worker子线程与宿主线程拥有独立的实例，包含基础设施、对象、代码段等，因此每个Worker启动存在一定的内存开销，需要限制Worker的子线程数量。当使用Worker模块具体功能时，均需先构造Worker实例对象，其构造函数与API版本相关，且构造函数需要传入Worker线程文件的路径（scriptURL）。
HarmonyOS 线程讲解（任务分发、线程通信）_鸿蒙开发线程怎么用
2501_90404912的博客
01-31 972
由该分发器分发的所有的任务都是按顺序执行，但是执行这些任务的线程并不是固定的。例如：dispatcher_a 派发的任务使用 dispatcher_b 进行任务的派发，在 dispatcher_b 派发的任务中又利用 dispatcher_a 进行派发任务。行任务分发器（dispatcher_a）派发的任务中利用串行任务分发器（dispatcher_b）进行同步派发任务，同时dispatcher_b 派发的任务中利用串行任务分发器（dispatcher_a）进行同步派发任务。
鸿蒙 线程讲解（任务分发、线程通信）
晨曦
10-24 9025
鸿蒙开发核心之线程讲解一、简单说明二、任务分发器① GlobalTaskDispatcher② ParallelTaskDispatcher③ SerialTaskDispatcher④ SpecTaskDispatcher⑤ 同步派发任务(syncDispatch)⑥ 异步派发任务(asyncDispatch)⑦ 异步延迟派发任务(delayDispatch)⑧ 任务组(Group)⑨ 取消任务(Revocable)⑩ 同步设置屏障任务 (syncDispatchBarrier)⑪ 异步设置屏障任务 (a
HarmonyOS 鸿蒙应用开发，线程间通信Emitter、Worker以及线程模型
wMeng_0923的博客
06-19 4483
线程是一个操作系统能够运算调度的最小单位，被包含在进程之中，也是进程中的实际运作单位。而在一个应用中（也就是同一个Bundle名）也许会有很多个进程，但是所有的UIAbility、ServiceExtensionAbility和DataShareExtensionAbility最终还是会运行在同一个主进程中，而同一类型的ExtensionAbility（除ServiceExtensionAbility和DataShareExtensionAbility外）均是运行在一个独立进程中。
鸿蒙HarmonyOS应用开发之Node-API开发
YHDMYBY的博客
08-23 1056
当传入napi_get_cb_info的argv不为nullptr时，argv的长度必须大于等于传入argc声明的大小。当argv不为nullptr时，napi_get_cb_info会根据argc声明的数量将JS实际传入的参数写入argv。如果argc小于等于实际JS传入参数的数量，该接口仅会将声明的argc数量的参数写入argv；而当argc大于实际参数数量时，该接口会在argv的尾部填充undefined。
鸿蒙（HarmonyOS）性能优化实战-多线程共享内存
CTrup的博客
09-20 1280
在应用开发中，为了避免主线程阻塞，提高应用性能，需要将一些耗时操作放在子线程中执行。此时，子线程就需要访问主线程中的数据。ArkTS采用了基于消息通信的Actor并发模型，具有内存隔离的特性，所以跨线程传输数据时需要将数据序列化，但是AkrTS支持通过可共享对象SharedArrayBuffer实现直接的共享内存。在开发应用时，如果遇到数据量较大，并且需要多个线程同时操作的情况，推荐使用SharedArrayBuffer共享内存，可以减少数据在线程间传递时需要复制和序列化的额外开销。
HarmonyOS应用开发-关于鸿蒙中的异步(Promise)和线程（taskPool,worker）
HarmonyOS_002的博客
07-04 3613
这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、Harmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。
鸿蒙多线程开发——线程间数据通信对象01
harmonyClassRoom的博客
11-21 1521
线程间通信指的是并发多线程间存在的数据交换行为。由于ArkTS语言兼容TS/JS，其运行时的实现与其它所有的JS引擎一样，都是基于Actor内存隔离的并发模型提供并发能力。对于不同的数据对象，在ArkTS线程间通信的行为是有差异的，比如普通JS对象、ArrayBuffer对象、SharedArrayBuffer对象等，跨线程的行为是不一致的，包括序列化反序列化拷贝、数据转移、数据共享等不同行为。
鸿蒙HarmonyOS开发：使用多线程共享内存场景
wqad23256的博客
11-22 1271
在应用开发中，为了避免主线程阻塞，提高应用性能，需要将一些耗时操作放在子线程中执行。此时，子线程就需要访问主线程中的数据。ArkTS采用了基于消息通信的Actor并发模型，具有内存隔离的特性，所以跨线程传输数据时需要将数据序列化，但是AkrTS支持通过可共享对象SharedArrayBuffer实现直接的共享内存。
鸿蒙实战开发：线程分析（任务分发、线程通信）
liuhaojiabin的博客
11-28 1048
说起鸿蒙的线程就不得不说Android的线程，相信都知道在Android中，每一个应用都会有自己的主线程和其他的子线程，主线程负责处理大部分业务，负责UI的显示和更新等操作，所以又称之为UI线程，同时，我们还知道不能够在UI线程中进行一些耗时操作，比如网络访问、数据读写等一些功能会启动一个子线程，或者异步线程来进行，这样做可以避免出现程序无法响应这样的情况，也就是ANR（Android Not Response）。后面三个字说的要快，并且带点伦敦郊区的口音，只要你的英语说的够快，别人就不知道你说的是中文。
【鸿蒙开发】第十五章 ArkTS基础类库-并发
Yvan
03-03 2857
为了提升应用的响应速度与帧率，以及防止耗时任务对主线程的干扰，系统提供了异步并发和多线程并发两种处理策略，ArkTS支持异步并发和多线程并发。并发能力在多种场景中都有应用，其中包括单次I/O任务CPU密集型任务I/O密集型任务和同步任务等。：是指异步代码在执行到一定程度后会被暂停，以便在未来某个时间点继续执行，这种情况下，同一时间只有一段代码在执行。Promise和提供异步并发能力，适用于单次I/O任务的开发场景。详细请参见异步并发概述。：允许在同一时间段内同时执行多段代码。
HarmonyOS 线程讲解（任务分发、线程通信）
maniuT的博客
01-31 2007
说起鸿蒙的线程就不得不说Android的线程，相信都知道在Android中，每一个应用都会有自己的主线程和其他的子线程，主线程负责处理大部分业务，负责UI的显示和更新等操作，所以又称之为UI线程，同时，我们还知道不能够在UI线程中进行一些耗时操作，比如网络访问、数据读写等一些功能会启动一个子线程，或者异步线程来进行，这样做可以避免出现程序无法响应这样的情况，也就是ANR（Android Not Response）。后面三个字说的要快，并且带点伦敦郊区的口音，只要你的英语说的够快，别人就不知道你说的是中文。
鸿蒙线程基础知识
舒小羽的博客
10-18 2356
https://developer.harmonyos.com/cn/docs/documentation/doc-guides/inter-thread-guidelines-0000000000038955 子线程如何返回到UI线程 https://developer.harmonyos.com/cn/docs/documentation/doc-guides/faq-ability-0000001125002304
鸿蒙OS 线程间通信
weixin_51705943的博客
09-17 1605
EventHandler 投递 InnerEvent 事件EventHandler 投递 InnerEvent 事件，并按照优先级和延时进行处理，开发步骤如下：创建 EventHandler 的子类，在子类中重写实现方法。
鸿蒙 开发中 进程 和 线程
最新发布
梦想不只是梦与想的博客
07-17 611
摘要：本文全面解析鸿蒙(HarmonyOS)开发中的进程与线程实现，对比进程(资源隔离单位)和线程(执行调度单位)的核心差异。重点介绍鸿蒙提供的TaskPool(轻量级线程池)和Worker(长时线程)两种多线程方案，包括代码示例和使用场景。同时涵盖线程同步、通信、性能优化等高级技巧，并通过多线程下载管理器案例展示实际应用。文章还总结了常见问题解决方案，帮助开发者构建高性能鸿蒙应用。
HarmonyOS 鸿蒙应用开发( 八、线程模型及线程间通信 Emitter、Worker和TaskPool介绍）
猫哥 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS，AIOT)
01-27 5955
在HarmonyOS应用中每个进程都会有一个主线程(UI线程)，用于处理UI更新、事件分发等操作。对于耗时任务，开发者需要创建工作线程进行处理，以避免阻塞主线程影响UI流畅性。主线程有如下职责：1.执行UI绘制，主线程负责处理与用户界面相关的所有操作，包括布局计算、渲染以及屏幕刷新等。在鸿蒙系统中，ArkTS引擎用于管理主线程上的UI渲染。2.管理主线程的ArkTS引擎实例，使多个UIAbility组件能够运行在其之上。
鸿蒙应用开发--emitter跨线程通信
2401_88846919的博客
03-10 1397
DATA_LOADED = 1001, // 也可用数字。
鸿蒙中的并发线程间通信、线程间通信对象
2301_79624024的博客
04-23 1529
并发线程间通信，线程间通信对象、Worker、TaskPool
鸿蒙开发Worker线程改写UI
01-01
### 鸿蒙 OS Worker 线程更新 UI 的方法 在鸿蒙操作系统中，Worker 是一种用于执行长时间运行的任务而不阻塞主线程的机制。由于 Worker 运行在一个独立的工作线程上，因此它无法直接访问或修改 UI 组件。为了实现从 Worker 线程向 UI 发送消息并更新界面的效果，通常采用以下几种方式： #### 使用 Emitter 实现线程间通信 Emitter 提供了一种发布/订阅模式的消息传递机制，允许不同线程之间发送和接收消息。可以在 Worker 中触发事件，在主线程监听这些事件来间接达到更新 UI 的目的。 ```typescript // 主线程代码片段 import emitter from '@ohos.event.emitter'; emitter.on('updateUI', (data) => { console.info(`Received data: ${JSON.stringify(data)}`); // 执行具体的UI更新逻辑 }); // Worker线程中的代码片段 export default function MyWorker() { let worker = new Worker(); worker.postMessage({ action: 'doSomething', payload: {} }); worker.onmessage = (event) => { const resultData = event.data; // 向主线程发出信号以请求刷新UI emitter.emit('updateUI', { message: "Update your UI here", ...resultData }); }; } ``` 此段代码展示了如何利用 `@ohos.event.emitter` 模块完成跨线程的数据交换[^1]。 #### 利用 AbilitySlice 上下文对象的方法调用 如果是在特定的应用场景比如Ability环境下工作，则可以直接借助AbilitySlice提供的接口来进行UI交互。例如，可以通过 abilityContext.runOnUIThread 来安排任务在UI线程上同步执行。 ```javascript abilityContext.runOnUiThread(() -> { // 在这里放置需要在线程中立即执行的操作 }); ``` 需要注意的是这种方法仅适用于某些特殊情况下，并不是通用解决方案[^3]。 #### 注意事项 - 创建过多的 Workers 可能会引起性能问题以及资源浪费；自 API 版本 9 起，当超过最大允许数目的时候将会引发初始化失败异常而不是简单的拒绝创建新的实例[^4]。 - 尽量减少不必要的线程切换次数，因为频繁地在这两者之间转换可能会带来额外开销影响程序效率。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值