[导读]  前面写了些文章分享C语言面向对象设计的一些个人体会，个人认为RT-Thread内核对于面向对象实现思想是一个非常好的设计。向这些在基础软件上深耕的国人大牛们致敬。本文基于学习RT-Thread内核设计的初衷，来分享一下个人对于其内核对象子系统设计的理解与体会。在此，也给各位RT-Thread原创大牛们打call，分享本文也期望有更多的盆友去学习并使用RT_Thread。
9 e- U. N. {- J! f& @
RT-Tread内核架构

RT-Thread，全称是 Real Time-Thread，顾名思义，它是一个嵌入式实时多线程操作系统，基本属性之一是支持多任务，允许多个任务同时运行并不意味着处理器在同一时刻真地执行了多个任务。其内核架构如下图所示：

RT-Thread 内核及底层结构

对于各部分的功能，这里不做展开描述。RT-Tread内核吸引我的方面：

• 代码优雅、可读性非常高
• 体积小巧、代码类Linux风格，可裁剪
• 社区活跃，国人自主开发，用户越来越多
• 优秀的设计，对于面向对象设计思想可以说是非常优秀的实践
• 主要定位于物联网应用，各种组件丰富，融合的也很好
• ........
  7 _, _2 V& b0 E# K( d# ^1 \

所以如果是RTOS应用或者开发从业者，面对这么优秀且比较容易深入学习的内核，如果不去好好读读，实在有点可惜。要去体会RT-Thread对象设计思想，从其对内核对象object的管理入手，不失为一个非常好的切入点。

什么是RT-Thread内核对象管理？

RT-Thread 采用内核对象管理系统来访问 / 管理所有内核对象，内核对象包含了内核中绝大部分设施，这些内核对象既可以是静态分配的静态对象，也可以是从系统内存堆中分配的动态对象。通过这种内核对象的设计方式，RT-Thread 做到了不依赖于具体的内存分配方式，系统的灵活性得到极大的提高。

RT-Thread 内核对象包括：线程，信号量，互斥量，事件，邮箱，消息队列和定时器，内存池，设备驱动等。对象容器中包含了每类内核对象的信息，包括对象类型，大小等。对象容器给每类内核对象分配了一个链表，所有的内核对象都被链接到该链表上，如图 RT-Thread 的内核对象容器及链表如下图所示：

RT-Thread 的内核对象容器及链表

参考自：https://www.rt-thread.org/docume ... ual/basic/basic/#_7

这个集中管理的内核对象容器在内存的开销方面代价很小，但却具有高度的灵活性，从设计的角度看其代码也非常利于扩展，增加新的内核对象类别，以及对于相应的内核对象功能的裁剪适配。

内核对象主要干什么？

RT-Thread内核对象子系统其主体实现代码为object.c,本文尝试从整体到局部来尝试解读其设计思想。object.c这个子系统从外部以黑盒的角度看，就个人理解主要实现了这样些用例需求：

所以个人理解内核对象管理器，主要是为其他内核功能模块提供数据管理支撑，属于内核底层支持功能组件，并从设计上兼顾了可扩展、可裁剪的需求。

怎么实现的呢？

RT-Thread内核对象子系统其主要核心数据结构如下：

其中rt_object_class_type枚举定义内核对象类别：

enum rt_object_class_type
{
    RT_Object_Class_Null   = 0,   /* 未使用        */
( A' D: K' v5 S* y6 v" F    RT_Object_Class_Thread,       /* thread对象    */
    RT_Object_Class_Semaphore,    /* semaphore对象 */
) T- _( b( y2 W2 A- F5 o# O    RT_Object_Class_Mutex,        /* mutex对象     */
    RT_Object_Class_Event,        /* event对象     */
0 Y7 y; W+ W9 P% B  T    RT_Object_Class_MailBox,      /* mail box对象  */
    RT_Object_Class_MessageQueue, /* message queue */
    RT_Object_Class_MemHeap,      /* memory heap   */
; i. B  ]! L: L5 _3 j( w+ D    RT_Object_Class_MemPool,      /* memory pool   */
    RT_Object_Class_Device,       /* device对象     */
    RT_Object_Class_Timer,        /* timer对象      */
5 g/ p& B* ?: C3 u5 y2 _/ g    RT_Object_Class_Module,       /* module        */
0 I# Y/ N; K) b% z    RT_Object_Class_Unknown,      /* unknown       */
0 a$ p! V* B: u2 r    RT_Object_Class_Static = 0x80 /*8位类型变量高位置1表示静态对象 */
) C7 K% ^6 H' o+ s8 O7 ]/ j};

而rt_object_information则抽象了对象类型，加入了一个双向链表指针数据域rt_list_node，从而将同类别的内核对象利用该双链指针链接起来，这些同类别的内核对象具有如下可能的特点：

• 可能在软件运行时生成，也可能在os初始化创建。
• 其存储类型可能为静态类型，也可能为动态类型（所谓动态类型这里是确指在内核堆上动态申请的内存区域用于存储相应的内核对象）。
• 在内存空间中，其位置并不连续。
  & s  j: j5 J, Q1 Q2 n0 O

如此以来，将这些内核对象在空间上不连续的变量，利用链表形成了可统一管理、可增可删、可检索的逻辑结构。

而rt_object_container内核容器，其本质是一个内核对象索引表，主要集中管理了下面的信息：

• enum rt_object_class_type type：内核对象类别，每项表记录条目的类别
• rt_list_t     object_list:每类对象链表的头结点的链表指针数据域
• rt_size_t    object_size：该类个体的大小
  

利用宏将相应的链表进行选编译，在内核关键数据进行了裁剪管理。而对于内核本身的扩展性而言，如果需要增加新的内核功能，可以方便的增加新的内核对象类，并能方便的加入到这个内核对象容器中，利用公共的对外接口，实现统一管理，而不必对数据管理层进行额外的接口设计。

实现了哪些对外接口呢？

有了这样一个优雅的数据结构设计，那么基于这样一个数据结构设计，相应就很容易实现其内核对象集中管理的对外服务接口，那么其主要的服务接口有哪些呢？

其中一部分主要接口实现对象的增加\删除\检索等，这里以rt_object_init接口为例，来简要分析一下其实现：

void rt_object_init(struct rt_object         *object,
                    enum rt_object_class_type type,
                    const char               *name)
{
) Y# c7 d7 K) b    register rt_base_t temp;
- u' ?0 Z9 X* O3 w# `: x( Z    struct rt_list_node *node = RT_NULL;
    struct rt_object_information *information;
#ifdef RT_USING_MODULE
    struct rt_dlmodule *module = dlmodule_self();
#endif

    /*1. 在容器中找到这是什么对象类*/
    information = rt_object_get_information(type);
    RT_ASSERT(information != RT_NULL);

    /* check object type to avoid re-initialization */

    /* 进入临界区保护 */
    rt_enter_critical();
    /* try to find object */
- c3 V* p! D! B, B6 H    for (node  = information->object_list.next;
' e) n, }* I0 M  i7 |( n0 J" c            node != &(information->object_list);
: @" d9 T5 u+ {5 ^- P( ]" u* N6 R            node  = node->next)
4 t1 k( L+ j: t8 x+ V* F& P    {
8 D* @9 i0 j, c5 Q' Z/ M3 K* R8 g        struct rt_object *obj;

8 D& k0 g, I/ `7 K0 ?& S        obj = rt_list_entry(node, struct rt_object, list);
        if (obj) /* skip warning when disable debug */
) x: a3 c" x/ Z# u        {
            RT_ASSERT(obj != object);
& Y+ y9 s. Y: C$ i, Q8 ]/ A) Q* c        }
    }
. O' e' B2 K( a) \$ s' \) [    /* 离开临界区 */
    rt_exit_critical();
: Y9 V7 ~" C  k4 S* T
    /* 初始化对象参数，并置为静态标记 */
    object->type = type | RT_Object_Class_Static;
6 @0 N) X, g3 C. I    rt_strncpy(object->name, name, RT_NAME_MAX);

% Q5 h; x6 O2 @/ P4 j8 t    RT_OBJECT_HOOK_CALL(rt_object_attach_hook, (object));
, R+ F/ S- q% x9 U  R/ q; g3 q
    /* 禁止硬件中断 */
    temp = rt_hw_interrupt_disable();

#ifdef RT_USING_MODULE
    if (module)
  ~) J, j5 Z5 h3 ]! s    {
* N: |& s/ m1 r( x7 T7 ?        rt_list_insert_after(&(module->object_list), &(object->list));
1 w. r* c, N; ]1 [: I1 x- g* T        object->module_id = (void *)module;
3 o. Z, U- h8 q. U    }
    else
#endif
2 }+ R) n/ C" v3 w) w    {
        /* 对象插入容器中相应对象分支链连 */
        rt_list_insert_after(&(information->object_list), &(object->list));
: b# w. C1 @& r- c) O    }

8 e6 _$ m5 Z- q    /* 开硬件中断 */
    rt_hw_interrupt_enable(temp);
3 X$ z* s" Y' Q$ c}

• 对于内核对象增加\删除其主要就是利用内核容器首先检索到链表头结点，然后再进一步做双向链表的基本操作，这里对于具体如何操作链表就不做展开赘述了。
• 对于内核对象相关数据域的检索、查询有了明确的数据结构，以及能检索到结点链表指针，由于结点链表指针与相应内核对象各数据域具有确定的相对位置关系，所以检索而言是非常易于实现的。
  # S2 i( E1 u0 R! l

而对于动态内核对象而言，其差异在于内核对象本身是动态申请的，这里需要注意的是向内核堆申请的，而不是C堆申请的，至于什么是内核堆，以及为什么要设计内核堆，之前有写过一篇文章分享，有兴趣可以去看看。

内核对象有什么相互继承关系？

RT-Thread管网上给出了这样一个相互关系图：

RT-Thread 内核对象继承关系

如果不去具体看相应数据结构，或许不易理解为啥有这样一张图。这里以上图中其中几个内核对象来撸一撸其相互关系：

或许有盆友会问，为啥rt_thread对象中明明没有直接包含rt_object，那为啥说rt_thread也是继承自rt_object呢？如果你细看看上图rt_thread中红框框出来的数据域就恍然大悟了，即便没有直接包含，但在内存中框里的内容就是rt_object的数据内容，所以利用指针转换就可以方便访问了，至于为什么是这样？我想可能是历史原因吧？所以rt_thread结构体前面几个数据域的位置是不可以修改的。这里还有盆友可能会问为什么ipc线程通信相关内核对象需要单独拎出来一个父结构体呢？我想应该是此类具有相同的一些共性，具有一些类似的特点。这也是对象设计提取共性进而抽象封装的一个体现。

总结一下

本文大致学习总结了一下RT-Thread内核对象子系统的设计思路的理解，从这里个人总结了一些启示：

• 软件是数据结构+算法，而良好的数据结构设计是优雅算法的基础，所以在工程开发中，如何设计好的数据结构抽象是一个可以深入挖掘的话题
• RT-Thread的内核对象设计个人认为非常易于理解，也是一个最佳实践。如有兴趣可以细细体会，多多揣摩。
  

+ i1 _6 T7 Z1 k+ m