鸿蒙OS开发线程管理详解(不同java的线程管理)

环境搭建和第一个demoAndroid开发编程,公众号:Android开发编程鸿蒙OS系统开发:环境搭建详解和运行Hello World

鸿蒙OS线程管理

图片

不同应用在各自独立的进程中运行。当应用以任何形式启动时,系统为其创建进程,该进程将持续运行。当进程完成当前任务处于等待状态,且系统资源不足时,系统自动回收。

在启动应用时,系统会为该应用创建一个称为“主线程”的执行线程。该线程随着应用创建或消失,是应用的核心线程。UI界面的显示和更新等操作,都是在主线程上进行。主线程又称UI线程,默认情况下,所有的操作都是在主线程上执行。如果需要执行比较耗时的任务(如下载文件、查询数据库),可创建其他线程来处理。

鸿蒙中线程管理开发

TaskDispatcher介绍

TaskDispatcher是一个任务分发器,它是Ability分发任务的基本接口,隐藏任务所在线程的实现细节。

为保证应用有更好的响应性,我们需要设计任务的优先级。在UI线程上运行的任务默认以高优先级运行,如果某个任务无需等待结果,则可以用低优先级。

图片

TaskDispatcher具有多种实现,每种实现对应不同的任务分发器。在分发任务时可以指定任务的优先级,由同一个任务分发器分发出的任务具有相同的优先级。系统提供的任务分发器有GlobalTaskDispatcher、ParallelTaskDispatcher、SerialTaskDispatcher 、SpecTaskDispatcher。

TaskDispatcher具有多种实现,每种实现对应不同的任务分发器。在分发任务时可以指定任务的优先级,由同一个任务分发器分发出的任务具有相同的优先级。系统提供的任务分发器有GlobalTaskDispatcher、ParallelTaskDispatcher、SerialTaskDispatcher 、SpecTaskDispatcher.

GlobalTaskDispatcher

全局并发任务分发器,由Ability执行getGlobalTaskDispatcher()获取。适用于任务之间没有联系的情况。一个应用只有一个GlobalTaskDispatcher,它在程序结束时才被销毁。

TaskDispatcher globalTaskDispatcher = getGlobalTaskDispatcher(TaskPriority.DEFAULT);

ParallelTaskDispatcher

并发任务分发器,由Ability执行createParallelTaskDispatcher()创建并返回。与GlobalTaskDispatcher不同的是,ParallelTaskDispatcher不具有全局唯一性,可以创建多个。开发者在创建或销毁dispatcher时,需要持有对应的对象引用 。

String dispatcherName = "parallelTaskDispatcher";
TaskDispatcher parallelTaskDispatcher = createParallelTaskDispatcher(dispatcherName, TaskPriori

SerialTaskDispatcher

串行任务分发器,由Ability执行createSerialTaskDispatcher()创建并返回。由该分发器分发的所有的任务都是按顺序执行,但是执行这些任务的线程并不是固定的。如果要执行并行任务,应使用ParallelTaskDispatcher或者GlobalTaskDispatcher,而不是创建多个SerialTaskDispatcher。如果任务之间没有依赖,应使用GlobalTaskDispatcher来实现。它的创建和销毁由开发者自己管理,开发者在使用期间需要持有该对象引用。

String dispatcherName = "serialTaskDispatcher";
TaskDispatcher serialTaskDispatcher = createSerialTaskDispatcher(dispatcherName, TaskPriority.DEFAULT);

SpecTaskDispatcher

专有任务分发器,绑定到专有线程上的任务分发器。目前已有的专有线程为UI线程,通过UITaskDispatcher进行任务分发。

UITaskDispatcher:绑定到应用主线程的专有任务分发器, 由Ability执行getUITaskDispatcher()创建并返回。由该分发器分发的所有的任务都是在主线程上按顺序执行,它在应用程序结束时被销毁。

TaskDispatcher uiTaskDispatcher = getUITaskDispatcher();

鸿蒙线程开发例子

syncDispatch

同步派发任务:派发任务并在当前线程等待任务执行完成。在返回前,当前线程会被阻塞。

如下代码示例展示了如何使用GlobalTaskDispatcher派发同步任务:


TaskDispatcher globalTaskDispatcher = getGlobalTaskDispatcher(TaskPriority.DEFAULT);
globalTaskDispatcher.syncDispatch(new Runnable() {
    @Override
    public void run() {
        HiLog.info(LABEL_LOG, "sync task1 run");
    }
});
HiLog.info(LABEL_LOG, "after sync task1");

globalTaskDispatcher.syncDispatch(new Runnable() {
    @Override
    public void run() {
        HiLog.info(LABEL_LOG, "sync task2 run");
    }
});
HiLog.info(LABEL_LOG, "after sync task2");

globalTaskDispatcher.syncDispatch(new Runnable() {
    @Override
    public void run() {
        HiLog.info(LABEL_LOG, "sync task3 run");
    }
});
HiLog.info(LABEL_LOG, "after sync task3");

// 执行结果如下:
// sync task1 run
// after sync task1
// sync task2 run
// after sync task2
// sync task3 run
// after sync task3

asyncDispatch

异步派发任务:派发任务,并立即返回,返回值是一个可用于取消任务的接口。

如下代码示例展示了如何使用GlobalTaskDispatcher派发异步任务:


TaskDispatcher globalTaskDispatcher = getGlobalTaskDispatcher(TaskPriority.DEFAULT);
Revocable revocable = globalTaskDispatcher.asyncDispatch(new Runnable() {
    @Override
    public void run() {
        HiLog.info(LABEL_LOG, "async task1 run");
    }
});
HiLog.info(LABEL_LOG, "after async task1");

// 执行结果可能如下:
// after async task1
// async task1 run

delayDispatch

异步延迟派发任务:异步执行,函数立即返回,内部会在延时指定时间后将任务派发到相应队列中。延时时间参数仅代表在这段时间以后任务分发器会将任务加入到队列中,任务的实际执行时间可能晚于这个时间。具体比这个数值晚多久,取决于队列及内部线程池的繁忙情况。

如下代码示例展示了如何使用GlobalTaskDispatcher延迟派发任务:

final long callTime = System.currentTimeMillis();
final long delayTime = 50L;
TaskDispatcher globalTaskDispatcher = getGlobalTaskDispatcher(TaskPriority.DEFAULT); 
Revocable revocable = globalTaskDispatcher.delayDispatch(new Runnable() {
    @Override
    public void run() {
        HiLog.info(LABEL_LOG, "delayDispatch task1 run");
        final long actualDelay = System.currentTimeMillis() - callTime;
        HiLog.info(LABEL_LOG, "actualDelayTime >= delayTime: %{public}b", (actualDelay >= delayTime));
    }
}, delayTime);
HiLog.info(LABEL_LOG, "after delayDispatch task1");

// 执行结果可能如下:
// after delayDispatch task1
// delayDispatch task1 run
// actualDelayTime >= delayTime : true

syncDispatchBarrier

同步设置屏障任务:在任务组上设立任务执行屏障,同步等待任务组中的所有任务执行完成,再执行指定任务。


String dispatcherName = "parallelTaskDispatcher";
TaskDispatcher dispatcher = createParallelTaskDispatcher(dispatcherName, TaskPriority.DEFAULT);
// 创建任务组。
Group group = dispatcher.createDispatchGroup();
// 将任务加入任务组,返回一个用于取消任务的接口。
dispatcher.asyncGroupDispatch(group, new Runnable() {
    @Override
    public void run() {
        HiLog.info(LABEL_LOG, "task1 is running");  // 1
    }
});
dispatcher.asyncGroupDispatch(group, new Runnable() {
    @Override
    public void run() {
        HiLog.info(LABEL_LOG, "task2 is running");  // 2
    }
});
    
dispatcher.syncDispatchBarrier(new Runnable() {
    @Override
    public void run() {  
        HiLog.info(LABEL_LOG, "barrier");  // 3
    }
});  
HiLog.info(LABEL_LOG, "after syncDispatchBarrier");  // 4

// 1和2的执行顺序不定;3和4总是在1和2之后按顺序执行。

// 可能的执行结果:
// task1 is running
// task2 is running
// barrier
// after syncDispatchBarrier

// 另外一种执行结果:
// task2 is running
// task1 is running
// barrier
// after syncDispatchBarrier

asyncDispatchBarrier

异步设置屏障任务:在任务组上设立任务执行屏障后直接返回,指定任务将在任务组中的所有任务执行完成后再执行。


TaskDispatcher dispatcher = createParallelTaskDispatcher("dispatcherName", TaskPriority.DEFAULT);
// 创建任务组。
Group group = dispatcher.createDispatchGroup();
// 将任务加入任务组,返回一个用于取消任务的接口。
dispatcher.asyncGroupDispatch(group, new Runnable() {
    @Override
    public void run() {
        HiLog.info(LABEL_LOG, "task1 is running");  // 1
    }
});
dispatcher.asyncGroupDispatch(group, new Runnable() {
    @Override
    public void run() {
        HiLog.info(LABEL_LOG, "task2 is running");  // 2
    }
});
    
dispatcher.asyncDispatchBarrier(new Runnable() {
    @Override
    public void run() {  
        HiLog.info(LABEL_LOG, "barrier");  // 3
    }
});  
HiLog.info(LABEL_LOG, "after asyncDispatchBarrier");  // 4

// 1和2的执行顺序不定,但总在3之前执行;4不需要等待1、2、3执行完成。

// 可能的执行结果:
// task1 is running
// task2 is running
// after asyncDispatchBarrier
// barrier


applyDispatch

执行多次任务:对指定任务执行多次。

如下代码示例展示了如何执行多次任务:


final int total = 10;
final CountDownLatch latch = new CountDownLatch(total);
final List<Long> indexList = new ArrayList<>(total);
TaskDispatcher dispatcher = getGlobalTaskDispatcher(TaskPriority.DEFAULT); 

// 执行任务 total 次。
dispatcher.applyDispatch((index) -> {
    indexList.add(index);
    latch.countDown();
}, total);
// 设置任务超时。
try {    
    latch.await();
} catch (InterruptedException exception) {
   HiLog.error(LABEL_LOG, "latch exception");
}
HiLog.info(LABEL_LOG, "list size matches, %{public}b", (total == indexList.size()));
// 执行结果:
// list size matches, true
阅读原文

简介:一个有10多年经验开发的android、java、前端等语言的老程序员,在这里一起聊聊技术,一起聊聊生活、一起聊聊中年危机的生存之道,一起进步一起加油,感兴趣的欢迎订阅;不定时的更新。欢迎关注微信公众号:Android开发编程
(0)
打赏 喜欢就点个赞支持下吧 喜欢就点个赞支持下吧

声明:本文来自“Android开发编程”,分享链接:https://www.zyxiao.com/p/290360    侵权投诉

网站客服
网站客服
内容投稿 侵权处理
分享本页
返回顶部