【RT-Thread读书笔记】5. RT-Thread 学习6章读后感（二）

传媒学子

【RT-Thread读书笔记】5. RT-Thread 学习6章读后感（二） [复制链接]

 

【RT-Thread读书笔记】5. RT-Thread 学习6章读后感

---线程的定义和线程切换的实现（二）

此次分享对应的是《RT-thread内核实现与应用开发实战指南》的第六章中6.4-6.5的内容。

6.4 定义就绪列表当线程创建好之后，我们需要把线程添加到就绪列表中，表示线程已经就绪，系统随时可以调度。
就绪列表在scheduler.c中定义（scheduler.c第一次使用需要在rtthread\3.0.3\src目录下新建，然后添加到工程的rtt/source组中。

1. /* 线程就绪列表 */
   
2. rt_list_t rt_thread_priority_table[RT_THREAD_PRIORITY_MAX];

复制代码

数组的下标对应了任务的优先级，从0~RT_THREAD_PRIORITY_MAX, 0优先级最高，同一优先级的线程插入到就绪列表的同一条链表中。
例如：
0   ----   task1->task2->task3..这里优先级为0的 级别有三个任务。
1   ----   。。。。。。。。。。。。。  

将线程插入到就绪列表：

1.         /* 将线程插入到就绪列表 */
   
2.         rt_list_insert_before( &(rt_thread_priority_table[0]),&(rt_flag1_thread.tlist) );

复制代码

6.5 实现调度器

调度器是操作系统的核心，顾名思义是实现任务的调度，即线程的切换，换句话说就是从就绪列表中找到优先级最高的线程，执行它。
包括一些全局变量和几个函数实现调度器，代码都在scheduler.c中。

在使用调度器前，必须初始化，调度器的初始化：

1. /*
   
2. *************************************************************************
   
3. *                             包含的头文件
   
4. *************************************************************************
   
5. */
   
6. #include <rtthread.h>
   
7. #include <rthw.h>
   
8. 
   
9. 
   
10. /*
    
11. *************************************************************************
    
12. *                                 全局变量
    
13. *************************************************************************
    
14. */
    
15. /* 线程控制块指针，用于指向当前线程 */
    
16. struct rt_thread *rt_current_thread;
    
17. 
    
18. /* 线程就绪列表 */
    
19. rt_list_t rt_thread_priority_table[RT_THREAD_PRIORITY_MAX];
    
20. 
    
21. /* 线程休眠列表 */
    
22. rt_list_t rt_thread_defunct;
    
23. 
    
24. 
    
25. /*
    
26. *************************************************************************
    
27. *                               函数实现
    
28. *************************************************************************
    
29. */
    
30. 
    
31. /* 初始化系统调度器 */
    
32. void rt_system_scheduler_init(void)
    
33. {        
    
34.         register rt_base_t offset;        
    
35. 
    
36.         
    
37.         /* 线程就绪列表初始化 */
    
38.         for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++)
    
39.         {
    
40.                         rt_list_init(&rt_thread_priority_table[offset]);
    
41.         }
    
42.         
    
43.         /* 初始化当前线程控制块指针 */
    
44.         rt_current_thread = RT_NULL;
    
45.         
    
46.         /* 初始化线程休眠列表，当线程创建好没有启动之前会被放入到这个列表 */
    
47.         rt_list_init(&rt_thread_defunct);
    
48. }
    
49. 
    
50. /* 启动系统调度器 */
    
51. void rt_system_scheduler_start(void)
    
52. {
    
53.         register struct rt_thread *to_thread;
    
54.         
    
55. 
    
56.         /* 手动指定第一个运行的线程 */
    
57.         to_thread = rt_list_entry(rt_thread_priority_table[0].next,
    
58.                                                           struct rt_thread,
    
59.                                                           tlist);
    
60.         rt_current_thread = to_thread;
    
61.                                                                                                                
    
62.         /* 切换到第一个线程，该函数在context_rvds.S中实现，在rthw.h声明，
    
63.        用于实现第一次任务切换。当一个汇编函数在C文件中调用的时候，
    
64.        如果有形参，则执行的时候会将形参传人到CPU寄存器r0。*/
    
65.         rt_hw_context_switch_to((rt_uint32_t)&to_thread->sp);
    
66. }
    
67. 
    
68. /* 系统调度 */
    
69. void rt_schedule(void)
    
70. {
    
71.         struct rt_thread *to_thread;
    
72.         struct rt_thread *from_thread;
    
73.         
    
74.         
    
75.         
    
76.         /* 两个线程轮流切换 */
    
77.         if( rt_current_thread == rt_list_entry( rt_thread_priority_table[0].next,
    
78.                                                                                                                        struct rt_thread,
    
79.                                                                                                                        tlist) )
    
80.         {
    
81.                 from_thread = rt_current_thread;
    
82.                 to_thread = rt_list_entry( rt_thread_priority_table[1].next,
    
83.                                                                                                                        struct rt_thread,
    
84.                                                                                                                        tlist);
    
85.           rt_current_thread = to_thread;
    
86.         }
    
87.         else
    
88.         {
    
89.                 from_thread = rt_current_thread;
    
90.                 to_thread = rt_list_entry( rt_thread_priority_table[0].next,
    
91.                                                                                                                                                  struct rt_thread,
    
92.                                                                                                                                                  tlist);
    
93.           rt_current_thread = to_thread;                                                                                                                                                
    
94.         }
    
95.         
    
96.         /* 产生上下文切换 */
    
97.         rt_hw_context_switch((rt_uint32_t)&from_thread->sp,(rt_uint32_t)&to_thread->sp);        
    
98.         
    
99. }

复制代码

主函数：

1. int main(void)
   
2. {        
   
3.         /* 硬件初始化 */
   
4.         /* 将硬件相关的初始化放在这里，如果是软件仿真则没有相关初始化代码 */        
   
5.         
   
6.         /* 调度器初始化 */
   
7.         rt_system_scheduler_init();
   
8.         
   
9.         
   
10.         /* 初始化线程 */
    
11.         rt_thread_init( &rt_flag1_thread,                 /* 线程控制块 */
    
12.                         flag1_thread_entry,               /* 线程入口地址 */
    
13.                         RT_NULL,                          /* 线程形参 */
    
14.                         &rt_flag1_thread_stack[0],        /* 线程栈起始地址 */
    
15.                         sizeof(rt_flag1_thread_stack) );  /* 线程栈大小，单位为字节 */
    
16.         /* 将线程插入到就绪列表 */
    
17.         rt_list_insert_before( &(rt_thread_priority_table[0]),&(rt_flag1_thread.tlist) );
    
18.         
    
19.         /* 初始化线程 */
    
20.         rt_thread_init( &rt_flag2_thread,                 /* 线程控制块 */
    
21.                         flag2_thread_entry,               /* 线程入口地址 */
    
22.                         RT_NULL,                          /* 线程形参 */
    
23.                         &rt_flag2_thread_stack[0],        /* 线程栈起始地址 */
    
24.                         sizeof(rt_flag2_thread_stack) );  /* 线程栈大小，单位为字节 */
    
25.         /* 将线程插入到就绪列表 */
    
26.         rt_list_insert_before( &(rt_thread_priority_table[1]),&(rt_flag2_thread.tlist) );
    
27.         
    
28.         /* 启动系统调度器 */
    
29.         rt_system_scheduler_start();
    
30. }

复制代码

线程切换牵扯到ARM指令，我觉得最大的原因是，线程切换应当尽量时间短且准确，因此采用汇编语言可能更接近底层。

其实不懂汇编，也能用好RTOS, 但当遇到比较棘手的问题时，可能有无能为力了，所以一名优秀的嵌入式电子工程师，应当尽可能的熟悉arm指令，熟悉底层知识，这样软硬结合，方能写出优美而又实用的code, 走的更远。

此内容由EEWORLD论坛网友传媒学子原创，如需转载或用于商业用途需征得作者同意并注明出处

沈婷婷

厉害

传媒学子

沈婷婷 发表于 2019-5-5 14:39
厉害

都是书上的知识，自己稍微总结提炼了一点，也在学习中。。

沈婷婷

传媒学子 发表于 2019-5-5 18:22
都是书上的知识，自己稍微总结提炼了一点，也在学习中。。

有学习的心态和精神就好。