RT-Thread 内核学习笔记 - 内核对象rt_object RT-Thread 内核学习笔记 - 内核对象管理 RT-Thread 内核学习笔记 - 内核对象操作API RT-Thread 内核学习笔记 - 内核对象初始化链表组织方式 RT…

                                                                                                                                                                                    RT-Thread 内核学习笔记 - 内核对象rt_object

RT-Thread 内核学习笔记 - 内核对象管理
RT-Thread 内核学习笔记 - 内核对象操作API

RT-Thread 内核学习笔记 - 内核对象初始化链表组织方式
RT-Thread 内核学习笔记 - 内核对象链表结构深入理解
RT-Thread 内核学习笔记 - 设备模型rt_device的理解
RT-Thread 内核学习笔记 - 理解defunct僵尸线程

一、RT-Thread内核学习

1.1 背景

目的还是学习并熟悉RT-Thread 操作系统。
从最简单的对象管理切入
了解操作系统最基本的组成单位：Object

1.2 内核对象API

内核对象的主要操作方法：内核文件：object.c中实现
![Test](https://oss-club.rt-thread.org/uploads/20210124/b807950824783f507017e4891c5dab82.png RT-Thread 内核学习笔记 - 内核对象操作API)

1.3 知识点

查看内核文件：object.c，发现的主要的几个知识点

1.4 验证与测试

光看内核代码，不如敲一敲（抄一下）。
可以使用模拟器，写几个测试函数，看看对象操作的流程。

测试用例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
  /* RT-Thread 内核对象学习 */
#include <rtthread.h>

struct _obj_type
{
    enum rt_object_class_type type;
    const char* name;
};

/* 静态的对象定义 */
static struct rt_object _obj[] = { 0 };

/* 测试用，线程对象 */
static const struct _obj_type _obj_tbl[] =
{
    { RT_Object_Class_Thread, "th_01" },
    { RT_Object_Class_Thread, "th_02" },
    { RT_Object_Class_Thread, "th_03" },
    { RT_Object_Class_Thread, "th_04" },
    { RT_Object_Class_Thread, "th_05" },
};

#define OBJ_TEST_TBL_SIZE       (sizeof(_obj_tbl) / sizeof(_obj_tbl[0]))

/* 静态初始化对象 */
void obj_test_init(void)
{
    rt_uint8_t index = 0;
    rt_uint8_t obj_size = 0;

    for (index = 0; index < OBJ_TEST_TBL_SIZE; index++)
    {
        rt_object_init(&_obj[index], _obj_tbl[index].type, _obj_tbl[index].name);
    }

/* 动态创建对象 obj_test_create thread1 */
void obj_test_create(uint8_t argc, char** argv)
{
    struct rt_object* obj = RT_NULL;

    if (argc >= 2)
    {
        rt_kprintf(" obj_name=%s\n", argv[1]);
    }

    obj = rt_object_find(argv[1], RT_Object_Class_Thread);
    if (obj != RT_NULL)
    {
        rt_kprintf("obj_name=%s, exist!!\n", obj->name);
        return;
    }
    else
    {
        rt_object_allocate(RT_Object_Class_Thread, argv[1]);
        rt_kprintf("create obj_name=%s\n", argv[1]);
    }

/* 对象的打印 */
void obj_test_dump(void)
{
    struct rt_object* obj_pointers[OBJ_TEST_TBL_SIZE + 10] = { 0 };

    obj_size = rt_object_get_pointers(RT_Object_Class_Thread, obj_pointers, sizeof(obj_pointers));
    rt_kprintf("object init : object size=%d\n", obj_size);

    rt_kprintf("| index |     name     |  flag  |  type  |\n");
    rt_kprintf("+-------+--------------+--------+--------+\n");
    for (index = 0; index < obj_size; index++)
    {
        if (obj_pointers[index] == RT_NULL)
        {
            break;
        }
        rt_kprintf("|  %03d  |  %10s  |   %02d   |  0x%02x  |\n", index,
            obj_pointers[index]->name, obj_pointers[index]->flag,
            obj_pointers[index]->type);
    }
}

/* 查找线程对象 */
void obj_test_find(uint8_t argc, char** argv)
{

    {
    }

    {
        rt_kprintf("find obj_name=%s\n", obj->name);
    }
    else
    {
        rt_kprintf("not find obj_name=%s\n", argv[1]);
    }

/* 静态对象 detach */
void obj_test_detach(uint8_t argc, char** argv)
{

    {
    }

    {
        rt_object_detach(obj);
        rt_kprintf("detach obj_name=%s\n", obj->name);
    }
    else
    {
    }

/* 动态对象 delete */
void obj_test_delete(uint8_t argc, char** argv)
{

    {
    }

    {
        rt_object_delete(obj);
        rt_kprintf("delete obj_name=%s\n", obj->name);
    }
    else
    {
    }

/* 导出命令 */
MSH_CMD_EXPORT(obj_test_init, object init test);
MSH_CMD_EXPORT(obj_test_create, obj create test);
MSH_CMD_EXPORT(obj_test_dump, object test dump);
MSH_CMD_EXPORT(obj_test_find, object test find);
MSH_CMD_EXPORT(obj_test_detach, object test detach);
MSH_CMD_EXPORT(obj_test_delete, object test del);
  ```  
 
#### 1.5 学习总结
 
##### 总结一
 
 发现：tshell 是动态创建的线程 
 发现：tidle 是静态的线程

msh />obj_test_dump
object init : object size=2

1
2
3
4
| index |     name     |  flag  |  type  |
+-------+--------------+--------+--------+
|  000  |      tshell  |   00   |  0x01  |
|  001  |      tidle0  |   00   |  0x81  |

msh />

1
2
3
4
5
6
7
8
  ```  
 
##### 总结二
 
 动态对象，创建后，内存占用增加。 
 动态对象，删除后，内存占用恢复 
 
 ```sql

msh />free

1
2
3
total memory: 8388580
used memory : 5164  /* 【5164】 内存原有大小 */
maximum allocated memory: 7336

msh />obj

1
2
3
4
5
6
obj_test_init
obj_test_create
obj_test_dump
obj_test_find
obj_test_detach
obj_test_delete

msh />obj_test_cre
msh />obj_test_create hello
obj_name=hello
create obj_name=hello
msh />fre

1
2
free
used memory : 5304   /* 【5304】 内存占用 */

msh />obj_test_delete hello
find obj_name=hello
delete obj_name=hello

used memory : 5164  /* 【5304】，内存占用恢复 */
总结三

静态初始化的对象，detach（剔除对象管理）后，内存占用不变。

msh />obj_test_init
msh />ob
msh />obj_test_du
object init : object size=7
| 000 | th_05 | 00 | 0x81 |
| 001 | th_04 | 00 | 0x81 |
| 002 | th_03 | 00 | 0x81 |
| 003 | th_02 | 00 | 0x81 |
| 004 | th_01 | 00 | 0x81 |
| 005 | tshell | 00 | 0x01 |
| 006 | tidle0 | 00 | 0x81 |
used memory : 5164
msh />obj_test_deta
msh />obj_test_detach th_04
obj_name=th_04
find obj_name=th_04
detach obj_name=th_04
object init : object size=6
| 001 | th_03 | 00 | 0x81 |
| 002 | th_02 | 00 | 0x81 |
| 003 | th_01 | 00 | 0x81 |
| 004 | tshell | 00 | 0x01 |
| 005 | tidle0 | 00 | 0x81 |

 
#### 1.6 总结
 
 RT-Thread 内核对象的管理并不复杂 
 相关的知识点，如链表的初始化、插入、遍历、通过链表指针获取对象指针等比较的重要。 
 掌握好内核对象的基本操作，为后面学习派生对象如：线程对象、设备对象等，打下基础。

本文标题： RTThread内核学习笔记

发布时间： 2024年01月22日 00:00

最后更新： 2025年12月30日 08:54

原始链接： https://haoxiang.eu.org/e2d62441/

版权声明： 本文著作权归作者所有，均采用CC BY-NC-SA 4.0许可协议，转载请注明出处！

赏
× 喜欢就赞赏一下呗！
打赏二维码