鸿蒙内核源码分析(线程概念篇) | 是谁在不断的折腾CPU

最新推荐文章于 2024-07-23 20:48:39 发布
最新推荐文章于 2024-07-23 20:48:39 发布
阅读量697 收藏 15
点赞数 7
分类专栏： OpenHarmony HarmonyOS 移动开发 文章标签： harmonyos 汇编 OpenHarmony 鸿蒙系统 鸿蒙内核
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maniuT/article/details/138326164
版权
移动开发 同时被 3 个专栏收录
956 篇文章 10 订阅
订阅专栏
HarmonyOS
871 篇文章 14 订阅
订阅专栏
OpenHarmony
695 篇文章 17 订阅
订阅专栏

本篇说清楚任务的问题

在鸿蒙内核线程(thread)就是任务(task)，也可以叫作业.线程是对外的说法，对内就叫任务.跟王二毛一样， 在公司叫你王董，回到家里还有领导，就叫二毛啊.这多亲切.在鸿蒙内核是大量的task，很少看到thread，只出现在posix层.当一个东西理解就行.

鸿蒙内核源码分析定位为深挖内核地基，构筑底层网图.就要见真身，剖真人.任务(LosTaskCB)原始真身如下，本篇一一剖析它，看看它的五脏六腑里到底是个啥.

typedef struct {
    VOID            *stackPointer;      /**< Task stack pointer */ //内核态栈指针，SP位置，切换任务时先保存上下文并指向TaskContext位置
    UINT16          taskStatus;         /**< Task status */   //各种状态标签，可以拥有多种标签，按位标识
    UINT16          priority;           /**< Task priority */  //任务优先级[0:31]，默认是31级
    UINT16          policy;    //任务的调度方式(三种 .. LOS_SCHED_RR )
    UINT16          timeSlice;          /**< Remaining time slice *///剩余时间片
    UINT32          stackSize;          /**< Task stack size */  //非用户模式下栈大小
    UINTPTR         topOfStack;         /**< Task stack top */  //非用户模式下的栈顶 bottom = top + size
    UINT32          taskID;             /**< Task ID */    //任务ID，任务池本质是一个大数组，ID就是数组的索引，默认 < 128
    TSK_ENTRY_FUNC  taskEntry;          /**< Task entrance function */ //任务执行入口函数
    VOID            *joinRetval;        /**< pthread adaption */ //用来存储join线程的返回值
    VOID            *taskSem;           /**< Task-held semaphore */ //task在等哪个信号量
    VOID            *taskMux;           /**< Task-held mutex */  //task在等哪把锁
    VOID            *taskEvent;         /**< Task-held event */  //task在等哪个事件
    UINTPTR         args[4];            /**< Parameter， of which the maximum number is 4 */ //入口函数的参数 例如 main (int argc，char *argv[])
    CHAR            taskName[OS_TCB_NAME_LEN]; /**< Task name */ //任务的名称
    LOS_DL_LIST     pendList;           /**< Task pend node */  //如果任务阻塞时就通过它挂到各种阻塞情况的链表上，比如OsTaskWait时
    LOS_DL_LIST     threadList;         /**< thread list */   //挂到所属进程的线程链表上
    SortLinkList    sortList;           /**< Task sortlink node */ //挂到cpu core 的任务执行链表上
    UINT32          eventMask;          /**< Event mask */   //事件屏蔽
    UINT32          eventMode;          /**< Event mode */   //事件模式
    UINT32          priBitMap;          /**< BitMap for recording the change of task priority， //任务在执行过程中优先级会经常变化，这个变量用来记录所有曾经变化
                                             the priority can not be greater than 31 */   //过的优先级，例如 ..01001011 曾经有过 0，1，3，6 优先级
    INT32           errorNo;            /**< Error Num */
    UINT32          signal;             /**< Task signal */ //任务信号类型，(SIGNAL_NONE，SIGNAL_KILL，SIGNAL_SUSPEND，SIGNAL_AFFI)
    sig_cb          sig;    //信号控制块，这里用于进程间通讯的信号，类似于 linux singal模块
#if (LOSCFG_KERNEL_SMP == YES)
    UINT16          currCpu;            /**< CPU core number of this task is running on */ //正在运行此任务的CPU内核号
    UINT16          lastCpu;            /**< CPU core number of this task is running on last time */ //上次运行此任务的CPU内核号
    UINT16          cpuAffiMask;        /**< CPU affinity mask， support up to 16 cores */ //CPU亲和力掩码，最多支持16核，亲和力很重要，多核情况下尽量一个任务在一个CPU核上运行，提高效率
    UINT32          timerCpu;           /**< CPU core number of this task is delayed or pended */ //此任务的CPU内核号被延迟或挂起
#if (LOSCFG_KERNEL_SMP_TASK_SYNC == YES)
    UINT32          syncSignal;         /**< Synchronization for signal handling */ //用于CPU之间 同步信号
#endif
#if (LOSCFG_KERNEL_SMP_LOCKDEP == YES) //死锁检测开关
    LockDep         lockDep;
#endif
#if (LOSCFG_KERNEL_SCHED_STATISTICS == YES) //调度统计开关，显然打开这个开关性能会受到影响，鸿蒙默认是关闭的
    SchedStat       schedStat;          /**< Schedule statistics */ //调度统计
#endif
#endif
    UINTPTR         userArea;   //使用区域，由运行时划定，根据运行态不同而不同
    UINTPTR         userMapBase;  //用户模式下的栈底位置
    UINT32          userMapSize;        /**< user thread stack size ，real size : userMapSize + USER_STACK_MIN_SIZE */
    UINT32          processID;          /**< Which belong process *///所属进程ID
    FutexNode       futex;    //实现快锁功能
    LOS_DL_LIST     joinList;           /**< join list */ //联结链表，允许任务之间相互释放彼此
    LOS_DL_LIST     lockList;           /**< Hold the lock list */ //拿到了哪些锁链表
    UINT32          waitID;             /**< Wait for the PID or GID of the child process */ //等待孩子的PID或GID进程
    UINT16          waitFlag;           /**< The type of child process that is waiting， belonging to a group or parent，
                                             a specific child process， or any child process */
#if (LOSCFG_KERNEL_LITEIPC == YES)
    UINT32          ipcStatus;   //IPC状态
    LOS_DL_LIST     msgListHead;  //消息队列头结点，上面挂的都是任务要读的消息
    BOOL            accessMap[LOSCFG_BASE_CORE_TSK_LIMIT];//访问图，指的是task之间是否能访问的标识，LOSCFG_BASE_CORE_TSK_LIMIT 为任务池总数
#endif
} LosTaskCB;

结构体还是比较复杂，虽一一都做了注解，但还是不够清晰，没有模块化.这里把它分解成以下六大块逐一分析:

第一大块:多核CPU相关块

#if (LOSCFG_KERNEL_SMP == YES) //多CPU核支持
    UINT16          currCpu;            /**< CPU core number of this task is running on */ //正在运行此任务的CPU内核号
    UINT16          lastCpu;            /**< CPU core number of this task is running on last time */ //上次运行此任务的CPU内核号
    UINT16          cpuAffiMask;        /**< CPU affinity mask， support up to 16 cores */ //CPU亲和力掩码，最多支持16核，亲和力很重要，多核情况下尽量一个任务在一个CPU核上运行，提高效率
    UINT32          timerCpu;           /**< CPU core number of this task is delayed or pended */ //此任务的CPU内核号被延迟或挂起
#if (LOSCFG_KERNEL_SMP_TASK_SYNC == YES)
    UINT32          syncSignal;         /**< Synchronization for signal handling */ //用于CPU之间 同步信号
#endif
#if (LOSCFG_KERNEL_SMP_LOCKDEP == YES) //死锁检测开关
    LockDep         lockDep;
#endif
#if (LOSCFG_KERNEL_SCHED_STATISTICS == YES) //调度统计开关，显然打开这个开关性能会受到影响，鸿蒙默认是关闭的
    SchedStat       schedStat;          /**< Schedule statistics */ //调度统计
#endif
#endif

鸿蒙内核支持多CPU，谁都知道多CPU当然好，效率高，快嘛，但凡事有两面性，在享受一个东西带来好处的同时，也得承担伴随它一起带来的麻烦和风险.多核有哪些的好处和麻烦，这里不展开说，后续有专门的文章和视频说明.任务可叫线程，或叫作业.CPU就是做作业的，多个CPU就是有多个能做作业的，一个作业能一鼓作气做完吗?

答案是:往往不行，因为现实不允许，作业可以有N多，而CPU数量非常有限，所以经常做着A作业被老板打断让去做B作业.这老板就是调度算法.A作业被打断回来接着做的还会是原来那个CPU吗?

答案是:不一定. 变量cpuAffiMask叫CPU亲和力，它的作用是可以指定A的作业始终是同一个CPU来完成， 也可以随便，交给调度算法，分到谁就谁来，这方面可以不挑.

第二大块:栈空间

    VOID            *stackPointer;      /**< Task stack pointer */  //内核态栈指针，SP位置，切换任务时先保存上下文并指向TaskContext位置.
    UINT32          stackSize;          /**< Task stack size */     //内核态栈大小
    UINTPTR         topOfStack;         /**< Task stack top */      //内核态栈顶 bottom = top + size

    UINTPTR         userArea;       //使用区域，由运行时划定，根据运行态不同而不同
    UINTPTR         userMapBase;    //用户态下的栈底位置
    UINT32          userMapSize;    /**< user thread stack size ，real size : userMapSize + USER_STACK_MIN_SIZE */

进程分内核态进程和用户态进程，这个区别表现在线程(任务)层面上就是

  • 内核态进程下创建的任务只有内核态的栈空间，OsTaskStackAlloc负责内核态栈空间的分配.OsTaskStackInit负责对内核态栈的初始化.
//任务栈初始化，非常重要的函数，返回任务上下文
  LITE_OS_SEC_TEXT_INIT VOID *OsTaskStackInit(UINT32 taskID， UINT32 stackSize， VOID *topStack， BOOL initFlag)
  {
      UINT32 index = 1;
      TaskContext *taskContext = NULL;

      if (initFlag == TRUE) {
          OsStackInit(topStack， stackSize);
      }
      taskContext = (TaskContext *)(((UINTPTR)topStack + stackSize) - sizeof(TaskContext));//上下文存放在栈的底部

      /* initialize the task context */ //初始化任务上下文
  #ifdef LOSCFG_GDB
      taskContext->PC = (UINTPTR)OsTaskEntrySetupLoopFrame;
  #else
      taskContext->PC = (UINTPTR)OsTaskEntry;//程序计数器，CPU首次执行task时跑的第一条指令位置
  #endif
      taskContext->LR = (UINTPTR)OsTaskExit;  /* LR should be kept， to distinguish it's THUMB or ARM instruction */
      taskContext->resved = 0x0;
      taskContext->R[0] = taskID;             /* R0 */
      taskContext->R[index++] = 0x01010101;   /* R1， 0x01010101 : reg initialed magic word */ //0x55
      for (; index < GEN_REGS_NUM; index++) {//R2 - R12的初始化很有意思，为什么要这么做？
          taskContext->R[index] = taskContext->R[index - 1] + taskContext->R[1]; /* R2 - R12 */
      }//R[2]=R[2]<<1=0xAA

  #ifdef LOSCFG_INTERWORK_THUMB // 16位模式
      taskContext->regPSR = PSR_MODE_SVC_THUMB; /* CPSR (Enable IRQ and FIQ interrupts， THUMNB-mode) */
  #else //用于设置CPSR寄存器
      taskContext->regPSR = PSR_MODE_SVC_ARM;   /* CPSR (Enable IRQ and FIQ interrupts， ARM-mode) */
  #endif

  #if !defined(LOSCFG_ARCH_FPU_DISABLE)
      /* 0xAAA0000000000000LL : float reg initialed magic word */
      for (index = 0; index < FP_REGS_NUM; index++) {
          taskContext->D[index] = 0xAAA0000000000000LL + index; /* D0 - D31 */
      }
      taskContext->regFPSCR = 0;
      taskContext->regFPEXC = FP_EN;
  #endif

      return (VOID *)taskContext;
  }

可以看到，初始化了任务上下文(TaskContext)，并将任务上下文放在了栈底，初始化任务上下文目的是为了在运行阶段先初始化R0~R15，CPSR寄存器的值.
保存上下文和恢复上下文都是针对寄存器值而言的.这个工作是在内核态的栈中完成的，也就是说一个任务的上下文就是保存在任务的内核态栈中.

OsTaskStackInit的返回值将赋给stackPointer，即寄存器SP

用户态进程下创建的任务除了有内核态的栈空间外，还有用户态栈空间.

  //用户任务使用栈初始化
  LITE_OS_SEC_TEXT_INIT VOID OsUserTaskStackInit(TaskContext *context， TSK_ENTRY_FUNC taskEntry， UINTPTR stack)
  {
      LOS_ASSERT(context != NULL);

  #ifdef LOSCFG_INTERWORK_THUMB
      context->regPSR = PSR_MODE_USR_THUMB;
  #else
      context->regPSR = PSR_MODE_USR_ARM;//工作模式:用户模式 + 工作状态:arm
  #endif
      context->R[0] = stack;//栈指针给r0寄存器
      context->SP = TRUNCATE(stack， LOSCFG_STACK_POINT_ALIGN_SIZE);//异常模式所专用的堆栈 segment fault 输出回溯信息
      context->LR = 0;//保存子程序返回地址 例如 a call b ，在b中保存 a地址
      context->PC = (UINTPTR)taskEntry;//入口函数
  }

注意看里面的内容用户栈的初始化时修改了任务的上下文内容，任务的上下文内容是始终保存在内核栈中，注意这个不要搞混了.OsUserTaskStackInit只是修改上下文地址中的内容.

context->SP的值被修改了，这个修改意味着任务被调度后首先是恢复上下文，即要重置SP寄存器的值，SP的值将被变成context->SP，由此就指向了用户栈空间运行
context->PC也被改变了，这意味着入口地址(代码段位置)也改变了.

context->LR默认是为0，不跳转到任务地方.
在后续每次调度上下文切换过程中，context的内容将不断的变化.

第三大块:资源竞争/同步

    VOID            *taskSem;           /**< Task-held semaphore */ //task在等哪个信号量
    VOID            *taskMux;           /**< Task-held mutex */  //task在等哪把锁
    VOID            *taskEvent;         /**< Task-held event */  //task在等哪个事件
    UINT32          eventMask;          /**< Event mask */   //事件屏蔽
    UINT32          eventMode;          /**< Event mode */   //事件模式
    FutexNode       futex;    //实现快锁功能
    LOS_DL_LIST     joinList;           /**< join list */ //联结链表，允许任务之间相互释放彼此
    LOS_DL_LIST     lockList;           /**< Hold the lock list */ //拿到了哪些锁链表
    UINT32          signal;             /**< Task signal */ //任务信号类型，(SIGNAL_NONE，SIGNAL_KILL，SIGNAL_SUSPEND，SIGNAL_AFFI)
    sig_cb          sig;

公司的资源是有限的，CPU自己也是公司的资源，除了它还有其他的设备，比如做作业用的黑板，用户A，B，C都可能用到，狼多肉少，咋搞?

互斥量(taskMux，futex)能解决这个问题，办事前先拿锁，拿到了锁的爽了，没有拿到的就需要排队，在lockList上排队，注意lockList是个双向链表，它是内核最重要的结构体，开篇就提过，没印象的看 (双向链表篇)，上面挂都是等锁进房间的西门大官人.这是互斥量的原理，解决任务间资源紧张的竞争性问题.

另外一个是用于任务的同步的信号量(sig_cb)，任务和任务之间是会有关联的，现实生活中公司的A，B用户之间本身有业务往来的正常，CPU在帮B做作业的时候发现前置条件是需要A完成某项作业才能进行，这时B就需要主动让出CPU先办完A的事.这就是信号量的原理，解决的是任务间的同步问题.

第四大块:任务调度
前面说过了作业N多，做作业的只有几个人，单核CPU等于只有一个人干活.那要怎么分配CPU，就需要调度算法.

    UINT16          taskStatus;         /**< Task status */   //各种状态标签，可以拥有多种标签，按位标识
    UINT16          priority;           /**< Task priority */  //任务优先级[0:31]，默认是31级
    UINT16          policy;    //任务的调度方式(三种 .. LOS_SCHED_RR )
    UINT16          timeSlice;          /**< Remaining time slice *///剩余时间片
    CHAR            taskName[OS_TCB_NAME_LEN]; /**< Task name */ //任务的名称
    LOS_DL_LIST     pendList;           /**< Task pend node */  //如果任务阻塞时就通过它挂到各种阻塞情况的链表上，比如OsTaskWait时
    LOS_DL_LIST     threadList;         /**< thread list */   //挂到所属进程的线程链表上
    SortLinkList    sortList;           /**< Task sortlink node */ //挂到cpu core 的任务执行链表上

是简单的先来后到(FIFO)吗? 当然也支持这个方式.鸿蒙内核用的是抢占式调度(policy)，就是可以插队，比优先级(priority)大小，[0，31]级，数字越大的优先级越低，跟考试一样，排第一才是最牛的.

鸿蒙排0的最牛! 想也想得到内核的任务优先级都是很高的，比如资源回收任务排第5，定时器任务排第0.够牛了吧.普通老百姓排多少呢?默认28级，惨!!!

另外任务有时间限制timeSlice，叫时间片，默认20ms，用完了会给你重置，发起重新调度，找出优先级高的执行，阻塞的任务(比如没拿到锁的，等信号量同步的，等读写消息队列的)都挂到pendList上，方便管理.

第五大块:任务间通讯

#if (LOSCFG_KERNEL_LITEIPC == YES)
    UINT32          ipcStatus;   //IPC状态
    LOS_DL_LIST     msgListHead;  //消息队列头结点，上面挂的都是任务要读的消息
    BOOL            accessMap[LOSCFG_BASE_CORE_TSK_LIMIT];//访问图，指的是task之间是否能访问的标识，LOSCFG_BASE_CORE_TSK_LIMIT 为任务池总数
#endif

这个很重要，解决任务间通讯问题，要知道进程负责的是资源的管理功能，什么意思?就是它不并负责内容的生产和消费，它只负责管理确保你的内容到达率和完整性.生产者和消费者始终是任务.进程管了哪些东西系列篇有专门的文章，请自行翻看.

liteipc是鸿蒙专有的通讯消息队列实现.简单说它是基于文件的，而传统的ipc消息队列是基于内存的.有什么区别也不在这里讨论，已有专门的文章分析.

第六大块:辅助工具
要知道任务对内核来说太重要了，是任务让CPU忙里忙外的，那中间出差错了怎么办，怎么诊断你问题出哪里了，就需要一些工具，比如死锁检测，比如占用CPU，内存监控 如下:

#if (LOSCFG_KERNEL_SMP_LOCKDEP == YES) //死锁检测开关
    LockDep         lockDep;
#endif
#if (LOSCFG_KERNEL_SCHED_STATISTICS == YES) //调度统计开关，显然打开这个开关性能会受到影响，鸿蒙默认是关闭的
    SchedStat       schedStat;          /**< Schedule statistics */ //调度统计
#endif

以上就是任务的五脏六腑，看清楚它鸿蒙内核的影像会清晰很多!

也为了积极培养鸿蒙生态人才，让大家都能学习到鸿蒙开发最新的技术，针对一些在职人员、0基础小白、应届生/计算机专业、鸿蒙爱好者等人群，整理了一套纯血版鸿蒙（HarmonyOS Next）全栈开发技术的学习路线。大家可以进行参考学习：https://qr21.cn/FV7h05

①全方位，更合理的学习路径：
路线图包括ArkTS基础语法、鸿蒙应用APP开发、鸿蒙能力集APP开发、次开发多端部署开发、物联网开发等九大模块，六大实战项目贯穿始终，由浅入深，层层递进，深入理解鸿蒙开发原理！

②多层次，更多的鸿蒙原生应用：
路线图将包含完全基于鸿蒙内核开发的应用，比如一次开发多端部署、自由流转、元服务、端云一体化等，多方位的学习内容让学生能够高效掌握鸿蒙开发，少走弯路，真正理解并应用鸿蒙的核心技术和理念。

③实战化，更贴合企业需求的技术点：
学习路线图中的每一个技术点都能够紧贴企业需求，经过多次真实实践，每一个知识点、每一个项目，都是码牛课堂鸿蒙研发团队精心打磨和深度解析的成果，注重对学生的细致教学，每一步都确保学生能够真正理解和掌握。

为了能让大家更好的学习鸿蒙（HarmonyOS NEXT）开发技术，这边特意整理了《鸿蒙开发学习手册》（共计890页），希望对大家有所帮助：https://qr21.cn/FV7h05

《鸿蒙开发学习手册》：https://qr21.cn/FV7h05

如何快速入门：

  1. 基本概念
  2. 构建第一个ArkTS应用
  3. ……

开发基础知识：https://qr21.cn/FV7h05

  1. 应用基础知识
  2. 配置文件
  3. 应用数据管理
  4. 应用安全管理
  5. 应用隐私保护
  6. 三方应用调用管控机制
  7. 资源分类与访问
  8. 学习ArkTS语言
  9. ……

基于ArkTS 开发：https://qr21.cn/FV7h05

  1. Ability开发
  2. UI开发
  3. 公共事件与通知
  4. 窗口管理
  5. 媒体
  6. 安全
  7. 网络与链接
  8. 电话服务
  9. 数据管理
  10. 后台任务(Background Task)管理
  11. 设备管理
  12. 设备使用信息统计
  13. DFX
  14. 国际化开发
  15. 折叠屏系列
  16. ……

鸿蒙开发面试真题（含参考答案）：https://qr21.cn/FV7h05

大厂鸿蒙面试题：：https://qr18.cn/F781PH

鸿蒙开发面试大盘集篇（共计319页）：https://qr18.cn/F781PH

1.项目开发必备面试题
2.性能优化方向
3.架构方向
4.鸿蒙开发系统底层方向
5.鸿蒙音视频开发方向
6.鸿蒙车载开发方向
7.鸿蒙南向开发方向

OpenHarmony_小贾
关注
专栏目录
鸿蒙内核源码分析(百篇博客分析）.pdf
09-23
《鸿蒙内核源码分析》是一份深入研究华为鸿蒙操作系统的内核源码的文档，通过百篇博客的分析，旨在帮助读者理解鸿蒙内核的核心机制和工作原理。文档涵盖了从基础数据结构、进程管理、时钟任务、任务调度到内存管理等...
HarmonyOS 线程讲解（任务分发、线程通信）
maniuT的博客
01-31 1644
说起鸿蒙的线程就不得不说Android的线程，相信都知道在Android中，每一个应用都会有自己的主线程和其他的子线程，主线程负责处理大部分业务，负责UI的显示和更新等操作，所以又称之为UI线程，同时，我们还知道不能够在UI线程中进行一些耗时操作，比如网络访问、数据读写等一些功能会启动一个子线程，或者异步线程来进行，这样做可以避免出现程序无法响应这样的情况，也就是ANR（Android Not Response）。后面三个字说的要快，并且带点伦敦郊区的口音，只要你的英语说的够快，别人就不知道你说的是中文。
鸿蒙next开发：app.json5配置文件示例
最新发布
DMZDAMS的博客
07-23 1108
先通过一个示例，整体认识一下app.json5配置文件。
2024年最全鸿蒙 线程讲解（任务分发、线程通信），HarmonyOS鸿蒙面试 高级
2401_84853434的博客
05-08 1090
, 10);在onStart()中调用//取消异步任务。
详细教程 - 进阶版 鸿蒙harmonyOS应用 第十七节——鸿蒙OS多线程编程指南
爱蹦跶的全栈大A阿
12-22 2509
线程是操作系统调度的最小单元,鸿蒙OS使用轻量级线程实现了良好的并发性能。相比进程间的切换,线程间切换成本更低,可以有效利用多核CPU。但直接使用线程也会增加编程复杂度。本文将详细介绍鸿蒙OS的多线程编程模型、线程间通信与同步机制、并发安全、最佳实践等内容。本文主要介绍了鸿蒙OS的多线程创建与同步互斥机制,解释了线程不安全的根本原因,并给出了设计实现线程安全的各种方式,最后提出了并发优化的最佳实践。多线程并发大大提高了程序执行效率,但也增加了编程难度。
鸿蒙线程基础知识
舒小羽的博客
10-18 2001
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
鸿蒙内核源码分析(百篇博客分析.挖透鸿蒙内核).pdf
04-29
10_内存主奴篇：内存主奴篇是鸿蒙内核源码分析的一篇，用于介绍内存管理的基本概念和实现方式，包括内存管理的重要性、MMU的作用等。 11_内存分配篇：内存分配篇是鸿蒙内核源码分析的一篇，用于介绍内存分配的基本...
鸿蒙内核源码分析(百篇博客.定期更新)_2021.4.27.pdf
04-27
鸿蒙操作系统（HarmonyOS），是由华为公司开发的一个分布式操作系统，旨在实现跨多种设备的无缝协作体验。鸿蒙内核作为其核心部分，提供了设备间连接和通信的能力，支持不同设备上应用程序的运行。 鸿蒙内核源码...
鸿蒙内核源码分析.pdf
04-28
鸿蒙操作系统是华为开发的一款面向全场景的分布式操作系统，其内核源码分析是理解其运行机制和设计思想的重要手段。以下是对文档内容的知识点归纳： 1. 精读鸿蒙内核源码的重要性：鸿蒙内核源码的分析与研究，可以...
鸿蒙内核源码分析：task是内核调度的单元
07-07
鸿蒙内核每个进程内的线程独立运行、独立调度，当前进程内线程的调度不受其它进程内线程的影响。鸿蒙内核中的线程采用抢占式调度机制，同时支持时间片轮转调度和FIFO调度方式。鸿蒙内核的线程一共有32个优先级(0-31)...
操作系统多线程与文件系统实现
03-11
使用turbo c提供interrupt关键，在每次时间片中断函数时保存现场的功能实现函数之间的切换；加上TCB管理的结构体，实现线程调度。 物理文件的存储结构 引导块区 FAT区 i节点区 数据区 实现的命令集 命令名称 使用举例 说明 format format 1024 格式化硬盘 open open filesystem 打开上次保存的文件系统 cd cd filename 改变当前目录 mkdir mkdir newdir 新建文件夹 create create newfile 新建文件 del del file 删除文件或文件夹 write write f a 以追加的形式写文件 write f 以覆盖的形式写文件 cat cat f 打印文件内容 ls ls 打印当前目录的子文件 print print 打印fat表的使用情况 flush flush 将内存中模拟的区域写到真实文件中 close close 结束此次操作，推出系统 cls cls 清屏
【最新鸿蒙应用开发】——开发中常见的进程、多线程以及场景
m0_68038853的博客
05-31 1123
EventHub模块提供了事件中心，提供订阅、取消订阅、触发事件的能力。EventHub不是全局的事件中心，不同的context对象拥有不同的EventHub对象，事件的订阅、取消订阅、触发都作用在某一个具体的EventHub对象上，因此不能用于虚拟机间或者进程间的事件传递。eventHub.emit({eventId:xx},数据) ：发布订阅eventHub.on({eventId:xx},()=>{}) ：订阅事件eventHub.off({eventId:xx},()=>{}) ：取消订阅。
鸿蒙 线程讲解（任务分发、线程通信）(1)，2024年最新鸿蒙app开发面试题
2401_84181108的博客
04-16 601
taskTime 小于当前时间，立即执行postTimingTask(Runnable task, long taskTime) | 发送一个 Runnable 任务到队列，在 taskTime 时间执行，如果taskTime 小于当前时间，立即执行，优先级为 LOW |串行任务分发器（dispatcher_a）派发的任务中利用串行任务分发器（dispatcher_b）进行同步派发任务，同时dispatcher_b 派发的任务中利用串行任务分发器（dispatcher_a）进行同步派发任务。
HarmonyOS鸿蒙app.json5配置文件
shudaoshanQAQ的博客
02-01 1515
如果你觉得这篇内容对你还蛮有帮助，我想邀请你帮我三个小忙：关注小编，同时可以期待后续文章ing🚀，不定期分享原创知识。想要获取更多完整鸿蒙最新VIP学习资料，请点击→纯血版全套鸿蒙HarmonyOS学习资料。
2024年HarmonyOS鸿蒙最全软考高级之信息系统案例分析七重奏-《3》(1)，腾讯面试gm
2401_84853495的博客
05-08 395
5、配置审计；6、发布管理和交付。
鸿蒙 线程讲解（任务分发、线程通信），211本硕如何通过字节跳动、百度、美团HarmonyOS鸿蒙面试
2401_84181108的博客
04-16 972
taskTime 小于当前时间，立即执行postTimingTask(Runnable task, long taskTime) | 发送一个 Runnable 任务到队列，在 taskTime 时间执行，如果taskTime 小于当前时间，立即执行，优先级为 LOW || sendTimingEvent(InnerEvent event, long taskTime) | 发送一个定时事件到队列，在 taskTime 时间执行，如果taskTime 小于当前时间，立即执行，优先级为 LOW |
鸿蒙开发笔记(二十七): 交互事件--手势
Waruler的博客
01-24 1795
交互事件--手势
v25.05 鸿蒙内核源码分析(并发并行) | 听过无数遍的两个概念 | 百篇博客分析HarmonyOS源码
鸿蒙研究站 | 每天死磕一点点 | 由内核源码切入挖透OpenHarmony技术栈
02-01 779
鸿蒙内核源码中文注解 >> 精读内核源码,中文注解分析,深挖地基工程,大脑永久记忆,四大源码仓每日同步更新 本篇说清楚并发并行 读本篇之前建议先读 鸿蒙内核源码分析(总目录) 进程+线程篇,会对并行并发更深的理解. 理解并发概念 并发（Concurrent）:多个线程在单个核心运行，同一时间只能一个线程运行，内核不停切换线程，看起来像同时运行，实际上是线程被高速的切换. 通俗好理解的比喻就是高速单行道,单行道指的是CPU的核数,跑的车就是线程(任务),进程就是管理车的公司,一个公司可以有很多
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值