|
先说点题外话，看了RTT的源代码，其实还挺感慨的，RTT源代码结构清晰，完整的面向对象编程方式，命名规范，实在是非常难得。希望能在之后的发展中继续把关代码风格审核，不要丢掉这个优秀的习惯。
首先还是先了解下rt_thread(基本版)类所包含的成员：
1.与object完全一样的部分，这个地方按道理是可以直接使用struct rt_object parent的，事实上除了rt_thread类以外，其他类也都是这样做的。
2.tlist用于rt_thread的一个双向链表，把每个rt_thread实例通过链表链接起来，方便通过name成员来查找对应的rt_thread.
3.sp一个数据指针，指向线程栈当前使用的地址，线程切换之后，用来保存MCU中寄存器sp中的数据。
4.entry一个函数指针，指向线程的入口函数。
5.parameter一个数据指针，指向传入线程的参数的数据地址。
6.stack_addr一个数据指针，指向为线程分配的栈所有数据的顶部，一旦分配完成在线程删除之前是一个固定值。
7.stack_size保存所分配的栈空间的大小。
8.error保存与线程相关的错误标志。
RTT申明了以下11种错误： ```#define RT_EOK 0 /*< There is no error /
define RT_ERROR 1 /*< A generic error happens / define RT_EtiMEOUT 2 /*< Timed out / define RT_EFULL 3 /*< The resource is full / define RT_EEMPTY 4 /*< The resource is empty / define RT_ENOMEM 5 /*< No memory / define RT_ENOSYS 6 /*< No system / define RT_EBUSY 7 /*< Busy / define RT_EIO 8 /*< IO error / define RT_EINTR 9 /*< Interrupted system call / define RT_EINVAL 10 /*< Invalid argument /``` 9.stat 保存线程现在处在的状态。
RTT的线程有以下7（6）种状态: ```#define RT_THREAD_INIT 0x00 /*< Initialized status /
define RT_THREAD_READY 0x01 /*< Ready status / define RT_THREAD_SUSPEND 0x02 /*< Suspend status / define RT_THREAD_RUNNING 0x03 /*< Running status / define RT_THREAD_BLOCK RT_THREAD_SUSPEND /*< Blocked status / define RT_THREAD_CLOSE 0x04 /*< Closed status / define RT_THREAD_STAT_MASK 0x0f``` 10.current_priority，init_priority这两个成员一个用来保存当前优先级，一个用来保存初始化的时候的优先级，当任务被启动的时候current_priority会被重新赋值为init_priority
11.number_mask与线程调度算法有关的一个参数，在调度器板块再来看这个部分。
12.init_tick，remaining_tick这两个成员在有相同优先级的线程同时运行的时候生效，init_tick记录当前线程在有相同优先级任务的时候的时间片长度，如init_tick=20则当运行20个tick后会进行线程切换。
13.thread_timer实例化了一个rt_timer类，该rt_timer主要用来定时唤醒线程，当线程获取s信号量或者互斥锁或邮箱、队列的时候会拥有一个超时时间，此时会配置这个软定时器，时间到后对线程进行唤醒。
14.cleanup一个函数指针，指向一个清理函数，当线程退出的时候，将会执行该函数。
15.user_data用户数据 ```struct rt_thread { / rt object / char name[RT_NAME_MAX]; /< the name of thread */ rt_uint8_t type; /< type of object / rt_uint8_t flags; /**< thread’s flags /
rt_list_t list; /**< the object list */ rt_list_t tlist; /**< the thread list */ /* stack point and entry */ void *sp; /**< stack point */ void *entry; /**< entry */ void *parameter; /**< parameter */ void *stack_addr; /**< stack address */ rt_uint32_t stack_size; /**< stack size */ /* error code */ rt_err_t error; /**< error code */ rt_uint8_t stat; /**< thread status */ /* priority */ rt_uint8_t current_priority; /**< current priority */ rt_uint8_t init_priority; /**< initialized priority */ if RT_THREAD_PRIORITY_MAX > 32 rt_uint8_t number; rt_uint8_t high_mask; endif rt_uint32_t number_mask; rt_ubase_t init_tick; /**< thread's initialized tick */ rt_ubase_t remaining_tick; /**< remaining tick */ struct rt_timer thread_timer; /**< built-in thread timer */ void (*cleanup)(struct rt_thread *tid); /**< cleanup function when thread exit */ rt_uint32_t user_data; /**< private user data beyond this thread */ };```
看完rt_thread包含的成员，挺多的，但每个成员的作用，还算是比较清晰的。那么我们继续来聊thread相关的函数。
主要是以下几个函数， ```rt_err_t rt_thread_init(struct rt_thread thread, const char name, void (entry)(void parameter), void parameter, void stack_start, rt_uint32_t stack_size, rt_uint8_t priority, rt_uint32_t tick); rt_err_t rt_thread_detach(rt_thread_t thread); rt_thread_t rt_thread_create(const char name, void (entry)(void parameter), void parameter, rt_uint32_t stack_size, rt_uint8_t priority, rt_uint32_t tick); rt_thread_t rt_thread_self(void); rt_thread_t rt_thread_find(char *name); rt_err_t rt_thread_startup(rt_thread_t thread); rt_err_t rt_thread_delete(rt_thread_t thread);
rt_err_t rt_thread_yield(void); rt_err_t rt_thread_delay(rt_tick_t tick); rt_err_t rt_thread_mdelay(rt_int32_t ms); rt_err_t rt_thread_control(rt_thread_t thread, int cmd, void arg); rt_err_t rt_thread_suspend(rt_thread_t thread); rt_err_t rt_thread_resume(rt_thread_t thread); void rt_thread_timeout(void parameter);```
可以看到作为继承于object的子类，rt_thread类基本上重写了object相关的所有函数，现在来逐一分析每个函数所做的操作：
一、首先是rt_thread_init()以及rt_thread_create()
rt_thread_init()与rt_thread_create()的差异同样是在一个是静态线程的初始化，一个是动态的创建线程，函数内部的差异仅仅是在rt_thread_create()会为创建的线程从堆中申请栈空间并为要实例化的rt_thread申请内存。
这两个函数可以看做C++中的构造函数。 ```rt_thread_t rt_thread_create(const char name, void (entry)(void parameter), void parameter, rt_uint32_t stack_size, rt_uint8_t priority, rt_uint32_t tick) { struct rt_thread thread; void stack_start; /**申请内存**/ thread = (struct rt_thread *)rt_object_allocate(RT_Object_Class_Thread, name); if (thread == RT_NULL) return RT_NULL;
stack_start = (void *)RT_KERNEL_MALLOC(stack_size); if (stack_start == RT_NULL) { /* allocate stack failure */ rt_object_delete((rt_object_t)thread); return RT_NULL; } /*/
/**成员初始化*/ _rt_thread_init(thread, name, entry, parameter, stack_start, stack_size, priority, tick); /*/ return thread; } RTM_EXPORT(rt_thread_create);```
两个函数最终都在_rt_thread_init()这个私有函数中进行成员初始化。
_rt_thread_init主要执行以下操作：
1.双向链表指针指向自身。
2.赋值入口函数地址。
3.赋值入口函数参数。
4.线程栈相关的初始化:
赋值栈顶地址，赋值栈大小。
将栈空间所有ram设置为’#’（一般是用做检测栈的使用率）。
调用rt_hw_stack_init()对栈顶数据进行初始化(这个设计到线程切换时，保存当前线程的相应PC地址，临时变量，以及MCU寄存器的值等既保存线程的上下文)，之后会详细介绍这个函数。
5.初始化优先级。
6.初始化init_tick，remaining_tick （作用上文提过）
7.初始化错误标志。
8.初始化线程状态。
9.初始化clean_up函数和user_data，这里直接初始化为0，默认不使用。
10.初始化定时器，将定时器的time_out回调设置为rt_thread_timeout()，这个函数会将线程从阻塞队列中移出，加入就绪队列，并将error成员置为RT_ETIMEOUT
11.调用rt_thread_inited_hook()钩子函数
```static rt_err_t _rt_thread_init(struct rt_thread *thread,
说到rt_hw_stack_init()函数，首先需要介绍下MCU里的程序的运行规律，在裸机环境下，程序的临时变量，函数的参数，代码运行的地址（PC）统统放在一个叫栈的地方，栈是MCU RAM 里面一段连续的内存空间，栈的大小一般在启动文件或者链接脚本里面指定， 最后由 C 库函数_main 进行初始化。
但是， 在多线程的RTOS中，每个线程都是独立的，互不干扰的，所以要为每个线程都分配独立的栈空间，这个栈空间可以是一个预先定义好的全局数组（静态创建的线程）， 也可以是动态分配的一段内存空间（动态创建的线程），但归根结底它们都存在于 MCU的RAM 中。
学过汇编指令的肯定都熟悉，当MCU执行中断或者跳转函数的时候，有一个保护现场的动作，把MCU相应的寄存器数据，SP指针，PC地址PUSH入栈，这些入栈出栈操作有些是MCU自动完成的，有些必须要通过程序要完成。入栈结束后再执行跳转，当中断结束后，要返回当前程序位置的时候再从栈中把数据取出来，重新跳转到之前程序位置，恢复临时变量的值，这就叫恢复现场。
这个两个步骤其实也就是RTOS实现线程切换的最根本的原理。
重新回到rt_hw_stack_init()函数，它其实完成的就是对线程栈的最基础的初始化。
首先在栈顶空出了4个字节，然后进行了8字节对齐操作，然后留出了空间用来存储stack_frame中的内容，stack_frame包含与CPU、FPU相关的一些寄存器(R0-R11,PC,LR等等)。 ```rt_uint8_t rt_hw_stack_init(void tentry, void parameter, rt_uint8_t stack_addr, void texit) { struct stack_frame stack_frame; rt_uint8_t *stk; unsigned long i;
stk = stack_addr + sizeof(rt_uint32_t); stk = (rt_uint8_t *)RT_ALIGN_DOWN((rt_uint32_t)stk, 8); stk -= sizeof(struct stack_frame); stack_frame = (struct stack_frame *)stk; /* init all register */ for (i = 0; i < sizeof(struct stack_frame) / sizeof(rt_uint32_t); i ++) { ((rt_uint32_t *)stack_frame)* = 0xdeadbeef; } stack_frame->exception_stack_frame.r0 = (unsigned long)parameter; /* r0 : argument */ stack_frame->exception_stack_frame.r1 = 0; /* r1 */ stack_frame->exception_stack_frame.r2 = 0; /* r2 */ stack_frame->exception_stack_frame.r3 = 0; /* r3 */ stack_frame->exception_stack_frame.r12 = 0; /* r12 */ stack_frame->exception_stack_frame.lr = (unsigned long)texit; /* lr */ stack_frame->exception_stack_frame.pc = (unsigned long)tentry; /* entry point, pc */ stack_frame->exception_stack_frame.psr = 0x01000000L; /* PSR */ if USE_FPU stack_frame->flag = 0; endif / USE_FPU / /* return task's current stack address */ return stk; }```
二、rt_err_t rt_thread_detach()和rt_thread_delete()
这两个函数都用来删除线程的，区别是第一个是作用到静态创建的线程，第二个的作用是删除动态创建的线程。
1.参数检查。
2.将线程移出调度器队列（线程将不会再被调度）
3.将线程的timer移出timer队列（timer将不会进行计时）
4.设置stat成员为RT_THREAD_CLOSE
5.对于动态创建的线程，直接将线程加入rt_thread_defunct队列，对于静态的线程，只有在有clean_up函数的时候才加入rt_thread_defunct。在idle任务中，会对处在defunct队列中的线程进行释放内存等收尾工作。 ```rt_err_t rt_thread_delete(rt_thread_t thread) { rt_base_t lock;
/* thread check */ RT_ASSERT(thread != RT_NULL); RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread); RT_ASSERT(rt_object_is_systemobject((rt_object_t)thread) == RT_FALSE); if ((thread->stat & RT_THREAD_STAT_MASK) != RT_THREAD_INIT) { /* remove from schedule */ rt_schedule_remove_thread(thread); } /* release thread timer */ rt_timer_detach(&(thread->thread_timer)); /* change stat */ thread->stat = RT_THREAD_CLOSE; /* disable interrupt */ lock = rt_hw_interrupt_disable(); /* insert to defunct thread list */ rt_list_insert_after(&rt_thread_defunct, &(thread->tlist)); /* enable interrupt */ rt_hw_interrupt_enable(lock); return RT_EOK; }
rt_err_t rt_thread_detach(rt_thread_t thread) { rt_base_t lock;
/* thread check */ RT_ASSERT(thread != RT_NULL); RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread); RT_ASSERT(rt_object_is_systemobject((rt_object_t)thread)); if ((thread->stat & RT_THREAD_STAT_MASK) != RT_THREAD_INIT) { /* remove from schedule */ rt_schedule_remove_thread(thread); } /* release thread timer */ rt_timer_detach(&(thread->thread_timer)); /* change stat */ thread->stat = RT_THREAD_CLOSE; /* detach object */ rt_object_detach((rt_object_t)thread); if (thread->cleanup != RT_NULL) { /* disable interrupt */ lock = rt_hw_interrupt_disable(); /* insert to defunct thread list */ rt_list_insert_after(&rt_thread_defunct, &(thread->tlist)); /* enable interrupt */ rt_hw_interrupt_enable(lock); } return RT_EOK; }```
三、rt_err_t rt_thread_startup()线程启动函数
启动函数主要执行了：
1.参数检查
2.将current_priority 重新赋值为init_priority
3.为number_mask赋值，调度器会使用，之后再说
4.将stat置为RT_THREAD_SUSPEND挂起状态
5.调用rt_thread_resume启动线程。
6.判断当前是否有线程在运行（既调度器是否启动），若有则启动一次调度（此时若线程具有最高优先级，则会切换到该线程开始运行） ```rt_err_t rt_thread_startup(rt_thread_t thread) { / thread check / RT_ASSERT(thread != RT_NULL); RT_ASSERT((thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_INIT); RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread);
/* set current priority to init priority */ thread->current_priority = thread->init_priority; /* calculate priority attribute */ if RT_THREAD_PRIORITY_MAX > 32 thread->number = thread->current_priority >> 3; /* 5bit */ thread->number_mask = 1L << thread->number; thread->high_mask = 1L << (thread->current_priority & 0x07); /* 3bit */ else thread->number_mask = 1L << thread->current_priority; endif RT_DEBUG_LOG(RT_DEBUG_THREAD, ("startup a thread:%s with priority:%d
", thread->name, thread->init_priority)); /* change thread stat */ thread->stat = RT_THREAD_SUSPEND; /* then resume it */ rt_thread_resume(thread); if (rt_thread_self() != RT_NULL) { /* do a scheduling */ rt_schedule(); } return RT_EOK; }```
四、rt_thread_control()函数
该函数根据参数cmd的不同有几种不同的功能，
cmd可取的值为： RT_THREAD_CTRL_CHANGE_PRIORITY 修改线程的优先级 RT_THREAD_CTRL_STARTUP 启动线程 RT_THREAD_CTRL_CLOSE 关闭删除线程
只有修改优先级是独有的功能 ```rt_err_t rt_thread_control(rt_thread_t thread, int cmd, void *arg) { register rt_base_t temp;
/* thread check */ RT_ASSERT(thread != RT_NULL); RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread); switch (cmd) { case RT_THREAD_CTRL_CHANGE_PRIORITY: /* disable interrupt */ temp = rt_hw_interrupt_disable(); /* for ready thread, change queue */ if ((thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_READY) { /* remove thread from schedule queue first */ rt_schedule_remove_thread(thread); /* change thread priority */ thread->current_priority = *(rt_uint8_t *)arg; /* recalculate priority attribute */ if RT_THREAD_PRIORITY_MAX > 32 thread->number = thread->current_priority >> 3; /* 5bit */ thread->number_mask = 1 << thread->number; thread->high_mask = 1 << (thread->current_priority & 0x07); /* 3bit */ else thread->number_mask = 1 << thread->current_priority; endif /* insert thread to schedule queue again */ rt_schedule_insert_thread(thread); } else { thread->current_priority = *(rt_uint8_t *)arg; /* recalculate priority attribute */ if RT_THREAD_PRIORITY_MAX > 32 thread->number = thread->current_priority >> 3; /* 5bit */ thread->number_mask = 1 << thread->number; thread->high_mask = 1 << (thread->current_priority & 0x07); /* 3bit */ else thread->number_mask = 1 << thread->current_priority; endif } /* enable interrupt */ rt_hw_interrupt_enable(temp); break; case RT_THREAD_CTRL_STARTUP: return rt_thread_startup(thread); ifdef RT_USING_HEAP case RT_THREAD_CTRL_CLOSE: return rt_thread_delete(thread); endif default: break; } return RT_EOK; }```
五、其他函数 （1）rt_thread_t rt_thread_self(void); （2）rt_thread_t rt_thread_find(char *name); （3）rt_err_t rt_thread_yield(void); （4）rt_err_t rt_thread_delay(rt_tick_t tick); （5）rt_err_t rt_thread_mdelay(rt_int32_t ms); （6）rt_err_t rt_thread_suspend(rt_thread_t thread); （7）rt_err_t rt_thread_resume(rt_thread_t thread); （8）void rt_thread_timeout(void *parameter);
（1）获取当前正在运行的线程指针。
（2）通过线程名字获取线程的句柄。
（3）yield这个单词不好翻译，简单的来说这个函数的功能就是进行一次线程切换，把当前线程加入到就绪队列的最末尾，同时执行就绪队列的第一个线程。
（4）（5）延时当前线程，具体方式是将当前线程悬挂，并启动线程的timer，当时间到了之后通过time_out回调唤醒任务。
（6）挂起线程。
挂起线程会将线程移出调度器队列，使得线程无法被调度，将线程状态置为RT_THREAD_SUSPEND，并关闭线程的timer，最后会调用rt_thread_suspend_hook()钩子函数
（7）恢复线程
恢复线程会将线程移出挂起队列（当线程被相应信号挂起的时候，就会被加入到对应信号的挂起队列中，等待信号被释放），重新加入调度器就绪队列。
（8）线程timer的time_out回调。
将线程的error设置为 -RT_ETIMEOUT，并加线程移出当前的队列，重新加入调度器就绪队列，并执行一次调度。
原作者：yushigengyu
| 
1
/7 
工商网监
湘ICP备2023018690号
1590
淘帖
32
