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

传媒学子

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

 

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

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

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

线程是RTOS的基础，非常重要，线程的切换是用汇编代码来实现的，应该就是汇编直接编写arm指令代码，实现线程切换，这样做的好处，相对于C来讲应该就是切换的速度更快。

为什么用汇编来实现线程切换？

可能就是用汇编更接近与底层，相对于C来讲，速度可能更快，因为在RTOS中，线程切换是一个非常频繁的操作，线程切换会使用栈或者堆等存储或者读取上下文。

1.线程的定义：

在裸机系统中，系统就一个线程，即main函数中的大循环；在RTOS中，有很多这样的大循环，每个大循环简称为一个线程。通过任务调度器等完成县城切换。

2.创建线程：

在裸机系统中，会有全局变量，子函数调用，以及中断发生，在系统运行时，这些东西存放在哪里，我们不用十分关注。但在RTOS中，存在很多线程，我们必须弄清楚这些东西的存放位置，这样才能调用它们，保证RTOS的正确运行。

通常这些参数会被存放在栈中，栈一般是RAM中的一段空间。在RTOS中，线程之间是相互独立的，互不干扰的，因此，我们要为每个线程分配自己独立的栈空间。因此，我们会发现为什么RTOS会占用比裸机系统要大一些的RAM空间。

定义线程栈：

1. [/align]rt_uint8_t rt_flag1_thread_stack[512];
   
2. rt_uint8_t rt_flag2_thread_stack[512];

复制代码

在RT-Thread中，所有涉及到数据类型的地方，都会在rtdef.h中重新定义：

1. /* RT-Thread basic data type definitions */
   
2. typedef signed   char                   rt_int8_t;      /**<  8bit integer type */
   
3. typedef signed   short                  rt_int16_t;     /**< 16bit integer type */
   
4. typedef signed   long                   rt_int32_t;     /**< 32bit integer type */
   
5. typedef unsigned char                   rt_uint8_t;     /**<  8bit unsigned integer type */
   
6. typedef unsigned short                  rt_uint16_t;    /**< 16bit unsigned integer type */
   
7. typedef unsigned long                   rt_uint32_t;    /**< 32bit unsigned integer type */
   
8. typedef int                             rt_bool_t;      /**< boolean type */
   
9. 
   
10. /* 32bit CPU */
    
11. typedef long                            rt_base_t;      /**< Nbit CPU related date type */
    
12. typedef unsigned long                   rt_ubase_t;     /**< Nbit unsigned CPU related data type */
    
13. 
    
14. typedef rt_base_t                       rt_err_t;       /**< Type for error number */
    
15. typedef rt_uint32_t                     rt_time_t;      /**< Type for time stamp */
    
16. typedef rt_uint32_t                     rt_tick_t;      /**< Type for tick count */
    
17. typedef rt_base_t                       rt_flag_t;      /**< Type for flags */
    
18. typedef rt_ubase_t                      rt_size_t;      /**< Type for size number */
    
19. typedef rt_ubase_t                      rt_dev_t;       /**< Type for device */
    
20. typedef rt_base_t                       rt_off_t;       /**< Type for offset */
    
21. 
    
22. /* boolean type definitions */
    
23. #define RT_TRUE                         1               /**< boolean true  */
    
24. #define RT_FALSE                        0               /**< boolean fails */

复制代码

3.定义线程函数：每个线程都是一个无限循环且不能返回的函数，其实就是以前裸机系统的main函数。

4.定义线程控制块：线程控制块是保存每个线程运行所需的所有信息的地方，例如线程的栈指针，线程名称，线程的各种参数等。系统可以通过线程控制块，实现对线程的调度。
      rt-thread中声明如下：

1. /*
   
2. *************************************************************************
   
3. *                               线程结构体
   
4. *************************************************************************
   
5. */
   
6. 
   
7. struct rt_thread
   
8. {
   
9.         void        *sp;                  /* 线程栈指针 */
   
10.         void        *entry;                  /* 线程入口地址 */
    
11.         void        *parameter;              /* 线程形参 */        
    
12.         void        *stack_addr;      /* 线程起始地址 */
    
13.         rt_uint32_t stack_size;       /* 线程栈大小，单位为字节 */
    
14.         
    
15.         rt_list_t   tlist;            /* 线程链表节点 */
    
16. };
    
17. typedef struct rt_thread *rt_thread_t;

复制代码

我们看到，这个结构体中，定义中使用了指针，其实指针这个东西真的很简单，就是一个tag，因为实际的物理地址比较长，一般是0xXXXXXXXXX, 为了方便，我们定义了一个指针，这个指针就代表这个实际的地址，而指针也是一个变量，它也会占用内存，因此会有指针的指针。建议好好理解一下指针， 因为有些老师在教书的时候，给大家灌输一种指针很难学，指针容易出错的错误理念，造成我们谈指色变，反正我是深受其害。希望有些老师在教书的时候，还是要客观的讲述一些东西，指针很重要，而不是指针很难用。这里多说了一点东西，有些地方可能理解有误，大家还是以书本讲述为准。
5.线程创建函数的实现：
      首先，是初始化函数：

1. #include <rtthread.h>
   
2. #include <rthw.h>
   
3. 
   
4. rt_err_t rt_thread_init(struct rt_thread *thread,
   
5.                         void (*entry)(void *parameter),
   
6.                         void             *parameter,
   
7.                         void             *stack_start,
   
8.                         rt_uint32_t       stack_size)
   
9. {
   
10.         rt_list_init(&(thread->tlist));
    
11.         
    
12.         thread->entry = (void *)entry;
    
13.         thread->parameter = parameter;
    
14. 
    
15.         thread->stack_addr = stack_start;
    
16.         thread->stack_size = stack_size;
    
17.         
    
18.         /* 初始化线程栈，并返回线程栈指针 */
    
19.         thread->sp = (void *)rt_hw_stack_init( thread->entry,
    
20.                                                    thread->parameter,
    
21.                                                                        (void *)((char *)thread->stack_addr + thread->stack_size - 4) );
    
22.         
    
23.         return RT_EOK;
    
24. }

复制代码

5.1实现链表相关函数
rt_list_init(&(thread->tlist)); 初始化线程链表节点，我们把线程控制块挂在链表中。

1. /*
   
2. *************************************************************************
   
3. *                               双向链表结构体
   
4. *************************************************************************
   
5. */
   
6. struct rt_list_node
   
7. {
   
8.     struct rt_list_node *next;              /* 指向后一个节点 */
   
9.     struct rt_list_node *prev;              /* 指向前一个节点 */
   
10. };
    
11. typedef struct rt_list_node rt_list_t;                  
    

复制代码

初始化链表节点：就是将节点中的next和pre这两个节点指针指向节点本身。
双向链表的插入，删除 对于实现任务控制是很重要的知识，建议大家认真掌握和理解这些内容，这些知识数据结构上都会有详细介绍，在这本书中也有很多介绍，这里就不多说了。

5.2 rt_hw_stack_init()函数

1. #include <rtthread.h>
   
2. 
   
3. /*
   
4. *************************************************************************
   
5. *                                 数据类型
   
6. *************************************************************************
   
7. */
   
8. struct exception_stack_frame
   
9. {
   
10.     /* 异常发生时自动保存的寄存器 */
    
11.         rt_uint32_t r0;
    
12.     rt_uint32_t r1;
    
13.     rt_uint32_t r2;
    
14.     rt_uint32_t r3;
    
15.     rt_uint32_t r12;
    
16.     rt_uint32_t lr;
    
17.     rt_uint32_t pc;
    
18.     rt_uint32_t psr;
    
19. };
    
20. 
    
21. struct stack_frame
    
22. {
    
23.     /* r4 ~ r11 register
    
24.           异常发生时需手动保存的寄存器 */
    
25.     rt_uint32_t r4;
    
26.     rt_uint32_t r5;
    
27.     rt_uint32_t r6;
    
28.     rt_uint32_t r7;
    
29.     rt_uint32_t r8;
    
30.     rt_uint32_t r9;
    
31.     rt_uint32_t r10;
    
32.     rt_uint32_t r11;
    
33. 
    
34.     struct exception_stack_frame exception_stack_frame;
    
35. };
    
36. /*
    
37. *************************************************************************
    
38. *                                 全局变量
    
39. *************************************************************************
    
40. */
    
41. 
    
42. /* 用于存储上一个线程的栈的sp的指针 */
    
43. rt_uint32_t rt_interrupt_from_thread;
    
44. 
    
45. /* 用于存储下一个将要运行的线程的栈的sp的指针 */
    
46. rt_uint32_t rt_interrupt_to_thread;
    
47. 
    
48. /* PendSV中断服务函数执行标志 */
    
49. rt_uint32_t rt_thread_switch_interrupt_flag;
    
50. 
    
51. 
    
52. /*
    
53. *************************************************************************
    
54. *                                 函数实现
    
55. *************************************************************************
    
56. */
    
57. /* 线程栈初始化 */
    
58. rt_uint8_t *rt_hw_stack_init(void       *tentry,
    
59.                              void       *parameter,
    
60.                              rt_uint8_t *stack_addr)
    
61. {
    
62.         
    
63.         
    
64.         struct stack_frame *stack_frame;
    
65.         rt_uint8_t         *stk;
    
66.         unsigned long       i;
    
67.         
    
68.         
    
69.         /* 获取栈顶指针
    
70.          rt_hw_stack_init 在调用的时候，传给stack_addr的是(栈顶指针)*/
    
71.         stk  = stack_addr + sizeof(rt_uint32_t);
    
72.         
    
73.         /* 让stk指针向下8字节对齐 */
    
74.         stk  = (rt_uint8_t *)RT_ALIGN_DOWN((rt_uint32_t)stk, 8);
    
75.         
    
76.         /* stk指针继续向下移动sizeof(struct stack_frame)个偏移 */
    
77.         stk -= sizeof(struct stack_frame);
    
78.         
    
79.         /* 将stk指针强制转化为stack_frame类型后存到stack_frame */
    
80.         stack_frame = (struct stack_frame *)stk;
    
81.         
    
82.         /* 以stack_frame为起始地址，将栈空间里面的sizeof(struct stack_frame)
    
83.         个内存初始化为0xdeadbeef */
    
84.         for (i = 0; i < sizeof(struct stack_frame) / sizeof(rt_uint32_t); i ++)
    
85.         {
    
86.                         ((rt_uint32_t *)stack_frame)[i] = 0xdeadbeef;[/i]
    
87. [i]        }[/i]
    
88.         
    
89.         /* 初始化异常发生时自动保存的寄存器 */
    
90.         stack_frame->exception_stack_frame.r0  = (unsigned long)parameter; /* r0 : argument */
    
91.         stack_frame->exception_stack_frame.r1  = 0;                        /* r1 */
    
92.         stack_frame->exception_stack_frame.r2  = 0;                        /* r2 */
    
93.         stack_frame->exception_stack_frame.r3  = 0;                        /* r3 */
    
94.         stack_frame->exception_stack_frame.r12 = 0;                        /* r12 */
    
95.         stack_frame->exception_stack_frame.lr  = 0;                        /* lr */
    
96.         stack_frame->exception_stack_frame.pc  = (unsigned long)tentry;    /* entry point, pc */
    
97.         stack_frame->exception_stack_frame.psr = 0x01000000L;              /* PSR */
    
98.         
    
99.         /* 返回线程栈指针 */
    
100.         return stk;
     
101. }
     
102. 
     

复制代码

下面是错误代码的定义：

1. /*
   
2. *************************************************************************
   
3. *                               错误码定义
   
4. *************************************************************************
   
5. */
   
6. /* RT-Thread 错误码重定义 */
   
7. #define RT_EOK                          0               /**< There is no error */
   
8. #define RT_ERROR                        1               /**< A generic error happens */
   
9. #define RT_ETIMEOUT                     2               /**< Timed out */
   
10. #define RT_EFULL                        3               /**< The resource is full */
    
11. #define RT_EEMPTY                       4               /**< The resource is empty */
    
12. #define RT_ENOMEM                       5               /**< No memory */
    
13. #define RT_ENOSYS                       6               /**< No system */
    
14. #define RT_EBUSY                        7               /**< Busy */
    
15. #define RT_EIO                          8               /**< IO error */
    
16. #define RT_EINTR                        9               /**< Interrupted system call */
    
17. #define RT_EINVAL                       10              /**< Invalid argument */

复制代码

下面在主函数中初始化线程：

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. }

复制代码

由于这一章内容较多，而且重要，我这边分为多期来学习这一章，今天先介绍到这里。

总结：
本文主要对RT-Thread的线程定义以及如何创建线程进行了梳理，创建线程又包括: 定义线程栈，定义线程函数，定义线程控制块，实现线程创建函数等内容，涵盖了数据结构的指针、栈、双向链表的知识，涉及C语言结构体等内容。
同时，结合rt-thread源码，学习了rt-thread关于这些内容的设计和实现。

下面会就书中“6.4实现就绪列表、6.5实现调度器、6.6实现main函数”等内容进行学习和梳理。

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

沈婷婷

我想问问你，创建线程是在单独的一个.c文件中吗？

传媒学子

沈婷婷 发表于 2019-5-6 14:02
我想问问你，创建线程是在单独的一个.c文件中吗？

库建好了，在哪里都行。
给你举个野火的实例：

1. 
   
2. /**
   
3.   *********************************************************************
   
4.   * @file    main.c
   
5.   * @author  fire
   
6.   * [url=home.php?mod=space&uid=252314]@version[/url] V1.0
   
7.   * [url=home.php?mod=space&uid=311857]@date[/url]    2018-xx-xx
   
8.   * [url=home.php?mod=space&uid=159083]@brief[/url]   RT-Thread 3.0 + STM32 工程模版
   
9.   *********************************************************************
   
10.   * @attention
    
11.   *
    
12.   * 实验平台:野火 F429挑战者 STM32 开发板
    
13.   * 论坛    :[url]http://www.firebbs.cn[/url]
    
14.   * 淘宝    :[url]https://fire-stm32.taobao.com[/url]
    
15.   *
    
16.   **********************************************************************
    
17.   */
    
18. 
    
19. /*
    
20. *************************************************************************
    
21. *                             包含的头文件
    
22. *************************************************************************
    
23. */
    
24. #include "board.h"
    
25. #include "rtthread.h"
    
26. 
    
27. 
    
28. /*
    
29. *************************************************************************
    
30. *                               变量
    
31. *************************************************************************
    
32. */
    
33. /* 定义线程控制块 */
    
34. static rt_thread_t led1_thread = RT_NULL;
    
35. 
    
36. /*
    
37. *************************************************************************
    
38. *                             函数声明
    
39. *************************************************************************
    
40. */
    
41. static void led1_thread_entry(void* parameter);
    
42. 
    
43. 
    
44. /*
    
45. *************************************************************************
    
46. *                             main 函数
    
47. *************************************************************************
    
48. */
    
49. /**
    
50.   * @brief  主函数
    
51.   * @param  无
    
52.   * @retval 无
    
53.   */
    
54. int main(void)
    
55. {       
    
56.     /*
    
57.          * 开发板硬件初始化，RTT系统初始化已经在main函数之前完成，
    
58.          * 即在component.c文件中的rtthread_startup()函数中完成了。
    
59.          * 所以在main函数中，只需要创建线程和启动线程即可。
    
60.          */
    
61.        
    
62.         led1_thread =                          /* 线程控制块指针 */
    
63.     rt_thread_create( "led1",              /* 线程名字 */
    
64.                       led1_thread_entry,   /* 线程入口函数 */
    
65.                       RT_NULL,             /* 线程入口函数参数 */
    
66.                       512,                 /* 线程栈大小 */
    
67.                       3,                   /* 线程的优先级 */
    
68.                       20);                 /* 线程时间片 */
    
69.                   
    
70.     /* 启动线程，开启调度 */
    
71.    if (led1_thread != RT_NULL)
    
72.         rt_thread_startup(led1_thread);
    
73.     else
    
74.         return -1;
    
75. }
    
76. 
    
77. /*
    
78. *************************************************************************
    
79. *                             线程定义
    
80. *************************************************************************
    
81. */
    
82. 
    
83. static void led1_thread_entry(void* parameter)
    
84. {       
    
85.     while (1)
    
86.     {
    
87.         LED1_ON;
    
88.         rt_thread_delay(500);   /* 延时500个tick */
    
89.         
    
90.         LED1_OFF;     
    
91.         rt_thread_delay(500);   /* 延时500个tick */                                
    
92. 
    
93.     }
    
94. }
    
95. 
    
96. /********************************END OF FILE****************************/
    

复制代码