浅析RTThread(基本版)类所包含的成员

只看该作者 · 2023-4-28 16:13

先说点题外话，看了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相关的函数。

只看该作者 · 2023-4-28 16:14

主要是以下几个函数，
```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,

只看该作者 · 2023-4-28 16:14

说到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，并加线程移出当前的队列，重新加入调度器就绪队列，并执行一次调度。