rt-thread线程源码分析

rt-thread操作系统是一个多线程的操作系统，线程对于rt-thread来说是一个很重要的概念，因此，必须掌握它。

1 线程控制块的数据结构

/** * Thread structure */struct rt_thread{    /* rt object *///这里就是rt_object的结构,其实也可以用rt_object parent来定义，估计线程在早些时候并没有这么做，后来也就没改过来    char        name[RT_NAME_MAX];                      /**< the name of thread */    rt_uint8_t  type;                                   /**< type of object */    rt_uint8_t  flags;                                  /**< thread's flags */    #ifdef RT_USING_MODULE//模块ID    void       *module_id;                              /**< id of application module */#endif    //内核对象链表    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_uint16_t stack_size;                             /**< stack size *///栈大小    /* error code */    rt_err_t    error;                                  /**< error code *///错误代码,用于IPC机制中，标志是否已经获取成功    rt_uint8_t  stat;                                   /**< thread stat *///线程的当前状态    /* 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;#if defined(RT_USING_EVENT)//与IPC机制事件相关的一些参数    /* thread event */    rt_uint32_t event_set; //此线程接收到的事件    rt_uint8_t  event_info;//此线程的事件过滤信息,用于过滤事件,只保留感兴趣的事件#endif    rt_ubase_t  init_tick;                              /**< thread's initialized tick *///初始tick    rt_ubase_t  remaining_tick;                         /**< remaining tick *///剩余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 *///析构函数的输入参数};typedef struct rt_thread *rt_thread_t;

上面代码其中线程控制块的内部成员number, high_mask, number_mask与线程调度时获获取当前最高优先级线程的算法有关，这里不做介绍，详情请见:http://blog.csdn.net/flydream0/article/details/8588584

event_set, evernt_info与事件相关，在后续讲到IPC机制的事件时将会提出，这里也先不做介绍.

2 线程创建及初始化

2.1 初始化线程

/*@{*//** * This function will initialize a thread, normally it's used to initialize a * static thread object. * * @param thread the static thread object * @param name the name of thread, which shall be unique * @param entry the entry function of thread * @param parameter the parameter of thread enter function * @param stack_start the start address of thread stack * @param stack_size the size of thread stack * @param priority the priority of thread * @param tick the time slice if there are same priority thread * * @return the operation status, RT_EOK on OK, -RT_ERROR on error */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){    /* thread check *///参数检查    RT_ASSERT(thread != RT_NULL);    RT_ASSERT(stack_start != RT_NULL);    /* init thread object */    rt_object_init((rt_object_t)thread, RT_Object_Class_Thread, name);//初始化内核对象    return _rt_thread_init(thread,                           name,                           entry,                           parameter,                           stack_start,                           stack_size,                           priority,                           tick);}

其中_rt_thread_init的函数如下定义:

static 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){    /* init thread list */    rt_list_init(&(thread->tlist));//初始化线程节点    thread->entry = (void *)entry;//入口函数    thread->parameter = parameter;//入口函数的参数    /* stack init */    thread->stack_addr = stack_start;//栈地址    thread->stack_size = (rt_uint16_t)stack_size;//栈大小    /* init thread stack */    rt_memset(thread->stack_addr, '#', thread->stack_size);//将栈内的所有字节初始化为'#'号    thread->sp = (void *)rt_hw_stack_init(thread->entry, thread->parameter,//初始化时设置sp的内容，rt_hw_stack_init是一个与具体MCU相关的函数，这里就不做介绍        (void *)((char *)thread->stack_addr + thread->stack_size - 4),        (void *)rt_thread_exit);    /* priority init */    RT_ASSERT(priority < RT_THREAD_PRIORITY_MAX);    thread->init_priority    = priority;//当前优先级和初始化优先级设置    thread->current_priority = priority;    /* tick init */    thread->init_tick      = tick;//初始化tick和剩余tick    thread->remaining_tick = tick;    /* error and flags */    thread->error = RT_EOK;//错误的状态，线程状态初始化时为RT_THREAD_INIT    thread->stat  = RT_THREAD_INIT;    /* initialize cleanup function and user data */    thread->cleanup   = 0;//线程析构函数及其参数    thread->user_data = 0;    /* init thread timer */    rt_timer_init(&(thread->thread_timer),//初始化线程的定时器                  thread->name,                  rt_thread_timeout,                  thread,                  0,                  RT_TIMER_FLAG_ONE_SHOT);    return RT_EOK;}

初始化函数将线程栈内容全部初始化为'#'号.

其中rt_thread_timeout的函数如下定义:

/** * This function is the timeout function for thread, normally which is invoked * when thread is timeout to wait some resource. * * @param parameter the parameter of thread timeout function */void rt_thread_timeout(void *parameter){    struct rt_thread *thread;    thread = (struct rt_thread *)parameter;    /* thread check */    RT_ASSERT(thread != RT_NULL);    RT_ASSERT(thread->stat == RT_THREAD_SUSPEND);    /* set error number */    thread->error = -RT_ETIMEOUT;//设置此线程的error为超时错误，这些IPC机制中非常有用，    /* remove from suspend list *///从挂起链表中移除    rt_list_remove(&(thread->tlist));    /* insert to schedule ready list */    rt_schedule_insert_thread(thread);//加入调度器    /* do schedule */    rt_schedule();//重新调度}

注:当线程进入睡眠时，程序将线程对应的定时器加入到定时器超时链表，一旦时间到达，则调用此定时器的超时处理函数，即rt_thread_timeout函数，可上源码可知，在这个线程定时器超时处理函数内，将会将线程加入到调度器。

此外,需要特别注意地是，此函数会将超时的线程的error设置为-RT_ETIMEOUT,用来标志此线程并未获得IPC，这在IPC机制中判断某个线程是否已成功获取某个IPC对象时非常有用。

此超时回调函数主要是将挂起的线程加入到调度器中进行重新调度，即唤醒它。

2.2 创建线程

/** * This function will create a thread object and allocate thread object memory * and stack. * * @param name the name of thread, which shall be unique * @param entry the entry function of thread * @param parameter the parameter of thread enter function * @param stack_size the size of thread stack * @param priority the priority of thread * @param tick the time slice if there are same priority thread * * @return the created thread object */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_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;}

3 线程的脱离及删除

3.1 脱离线程

/** * This function will detach a thread. The thread object will be removed from * thread queue and detached/deleted from system object management. * * @param thread the thread to be deleted * * @return the operation status, RT_EOK on OK, -RT_ERROR on error */rt_err_t rt_thread_detach(rt_thread_t thread){    rt_base_t lock;    /* thread check */    RT_ASSERT(thread != RT_NULL);    /* remove from schedule */    rt_schedule_remove_thread(thread);//将线程从调度器中移除    /* release thread timer */    rt_timer_detach(&(thread->thread_timer));//脱离定时器    /* change stat */    thread->stat = RT_THREAD_CLOSE;//将线程的状态设置为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_thread_defunct链表在系统空闲时将被空闲线程来处理        rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));//将线程加入到rt_thread_defunct链表中        /* enable interrupt */        rt_hw_interrupt_enable(lock);//开中断    }    return RT_EOK;}

需要注意地是，线程的脱离函数如果当前线程离开进行一些善后工作，即存在cleanup析构函数，此时，会将此线程加入到回收线程链表rt_thread_defunct中去，等到系统空闲时再由空闲线程来“回收"此线程，详情请参考:http://blog.csdn.net/flydream0/article/details/8590415 一文.

3.2 删除线程

/** * This function will delete a thread. The thread object will be removed from * thread queue and detached/deleted from system object management. * * @param thread the thread to be deleted * * @return the operation status, RT_EOK on OK, -RT_ERROR on error */rt_err_t rt_thread_delete(rt_thread_t thread){    rt_base_t lock;    /* thread check */    RT_ASSERT(thread != RT_NULL);    /* remove from schedule */    rt_schedule_remove_thread(thread);//从调度器中移除线程    /* release thread timer */    rt_timer_detach(&(thread->thread_timer));//脱离定时器    /* change stat */    thread->stat = RT_THREAD_CLOSE;//线程状态设置为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;}

4 启动线程

/** * This function will start a thread and put it to system ready queue * * @param thread the thread to be started * * @return the operation status, RT_EOK on OK, -RT_ERROR on error */rt_err_t rt_thread_startup(rt_thread_t thread){    /* thread check *///参数检查    RT_ASSERT(thread != RT_NULL);    RT_ASSERT(thread->stat == RT_THREAD_INIT);    /* 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\n",                                   thread->name, thread->init_priority));    /* change thread stat */    thread->stat = RT_THREAD_SUSPEND;//将线程的状态设置为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_self函数为获取当前线程，其源码如下定义:

/** * This function will return self thread object * * @return the self thread object */rt_thread_t rt_thread_self(void){    return rt_current_thread;}

rt_current_thread为全局变量，保存当前正在运行的线程。

rt_thread_resume函数见后第6章内容,rt_schedule函数见线程调度源码分析相关章节.

5 线程挂起

/** * This function will suspend the specified thread. * * @param thread the thread to be suspended * * @return the operation status, RT_EOK on OK, -RT_ERROR on error * * @note if suspend self thread, after this function call, the * rt_schedule() must be invoked. */rt_err_t rt_thread_suspend(rt_thread_t thread){    register rt_base_t temp;    /* thread check */    RT_ASSERT(thread != RT_NULL);    RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread suspend:  %s\n", thread->name));    if (thread->stat != RT_THREAD_READY)//此函数只对处于就绪状态的线程操作    {        RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread suspend: thread disorder, %d\n",                                       thread->stat));                return -RT_ERROR;    }    /* disable interrupt */    temp = rt_hw_interrupt_disable();//关中断    /* change thread stat */    thread->stat = RT_THREAD_SUSPEND;//将线程设置为挂起状态    rt_schedule_remove_thread(thread);//将线程从调试器中移除    /* enable interrupt */    rt_hw_interrupt_enable(temp);//开中断    return RT_EOK;}

有关rt_schedule_remove_thread函数见后续在前调度器源码分析的文章。

此函数比较简单。

6 线程唤醒

/** * This function will resume a thread and put it to system ready queue. * * @param thread the thread to be resumed * * @return the operation status, RT_EOK on OK, -RT_ERROR on error */rt_err_t rt_thread_resume(rt_thread_t thread){    register rt_base_t temp;    /* thread check */    RT_ASSERT(thread != RT_NULL);    RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread resume:  %s\n", thread->name));    if (thread->stat != RT_THREAD_SUSPEND)//只对处于挂起的线程进行还原操作    {        RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread resume: thread disorder, %d\n",                                       thread->stat));        return -RT_ERROR;    }    /* disable interrupt */    temp = rt_hw_interrupt_disable();//关中断    /* remove from suspend list */    rt_list_remove(&(thread->tlist));//从挂起队列中移除    /* remove thread timer */    rt_list_remove(&(thread->thread_timer.list));//因线程即将运行，所以需要移除定时器，无需再定时    /* change timer state */    thread->thread_timer.parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;//将内核对象的标志设置为定时器非激活标志    /* enable interrupt */    rt_hw_interrupt_enable(temp);//开中断    /* insert to schedule ready list */    rt_schedule_insert_thread(thread);//将线程加入调度器    return RT_EOK;}

由上源码可见，此函数只是将线程加入到调度器就绪队列中，并没有真正唤醒它，而真正唤醒线程需要rt_schedule.

7 线程让出处理机

当前线程的时间片用完或者该线程自动要求让出处理器资源时，它不再占有处理机，调度器会选择下一个最高优先级的线程执行。这时，放弃处理器资源的线程仍然在就绪队列中,只不过放到就绪队列末尾去 了.

/** * This function will let current thread yield processor, and scheduler will * choose a highest thread to run. After yield processor, the current thread * is still in READY state. * * @return RT_EOK */rt_err_t rt_thread_yield(void){    register rt_base_t level;    struct rt_thread *thread;    /* disable interrupt */    level = rt_hw_interrupt_disable();//关中断    /* set to current thread */    thread = rt_current_thread;//得到当前线程    /* if the thread stat is READY and on ready queue list */    if (thread->stat == RT_THREAD_READY &&//如果当前线程处于就绪状态且在就绪队列        thread->tlist.next != thread->tlist.prev)    {        /* remove thread from thread list */        rt_list_remove(&(thread->tlist));//从就绪队列中移除当前线程        /* put thread to end of ready queue */        rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]),//加入到就绪队列末尾                              &(thread->tlist));        /* enable interrupt */        rt_hw_interrupt_enable(level);//开中断        rt_schedule();//重新调度线程        return RT_EOK;    }    /* enable interrupt */    rt_hw_interrupt_enable(level);//开中断    return RT_EOK;}

此函数用于线程的时间片耗尽时，就此线程挂起后加入到就绪队列的末端，然后再等待下一次调度。

8 线程睡眠

/** * This function will let current thread sleep for some ticks. * * @param tick the sleep ticks * * @return RT_EOK */rt_err_t rt_thread_sleep(rt_tick_t tick){    register rt_base_t temp;    struct rt_thread *thread;    /* disable interrupt */    temp = rt_hw_interrupt_disable();//关中断    /* set to current thread */    thread = rt_current_thread;//得到当前线程    RT_ASSERT(thread != RT_NULL);    /* suspend thread */    rt_thread_suspend(thread);//挂起当前线程    /* reset the timeout of thread timer and start it */    rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &tick);//设置定时器    rt_timer_start(&(thread->thread_timer));//启动定时器    /* enable interrupt */    rt_hw_interrupt_enable(temp);//开中断    rt_schedule();//启动调度器    /* clear error number of this thread to RT_EOK */    if (thread->error == -RT_ETIMEOUT)//将当前线程的错误码设置为超时        thread->error = RT_EOK;    return RT_EOK;}

/** * This function will let current thread delay for some ticks. * * @param tick the delay ticks * * @return RT_EOK */rt_err_t rt_thread_delay(rt_tick_t tick){    return rt_thread_sleep(tick);}

此函数是将当前线程挂起后，然后开启线程中的定时器，并等待定时器时间到达，一旦到达，定时器超时回调函数中将会将此线程重新加入到就绪队列，并重新调度。见2.1节的rt_thread_timeout函数实现部分。

9 线程控制

/** * This function will control thread behaviors according to control command. * * @param thread the specified thread to be controlled * @param cmd the control command, which includes *  RT_THREAD_CTRL_CHANGE_PRIORITY for changing priority level of thread; *  RT_THREAD_CTRL_STARTUP for starting a thread; *  RT_THREAD_CTRL_CLOSE for delete a thread. * @param arg the argument of control command * * @return RT_EOK */rt_err_t rt_thread_control(rt_thread_t thread, rt_uint8_t cmd, void *arg){    register rt_base_t temp;    /* thread check */    RT_ASSERT(thread != RT_NULL);    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_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;}

此函数在修改线程优先级时，当线程处于就绪状态时，为了安全起见，首先将线程从就绪队列中移除，然后再修改优先级，最后再次线程重新加入到调度器的就绪队列中。

10 查找线程

/** * This function will find the specified thread. * * @param name the name of thread finding * * @return the found thread * * @note please don't invoke this function in interrupt status. */rt_thread_t rt_thread_find(char *name){    struct rt_object_information *information;    struct rt_object *object;    struct rt_list_node *node;    extern struct rt_object_information rt_object_container[];    /* enter critical */    if (rt_thread_self() != RT_NULL)        rt_enter_critical();//进入临界区    /* try to find device object */    information = &rt_object_container[RT_Object_Class_Thread];//从内核对象容器中获取内核对象链表    for (node  = information->object_list.next;         node != &(information->object_list);         node  = node->next)    {        object = rt_list_entry(node, struct rt_object, list);//得到内核对象        if (rt_strncmp(object->name, name, RT_NAME_MAX) == 0)//比较名字        {            /* leave critical */            if (rt_thread_self() != RT_NULL)                rt_exit_critical();//退出临界区            return (rt_thread_t)object;//返回内核对象        }    }    /* leave critical */    if (rt_thread_self() != RT_NULL)        rt_exit_critical();//退出临界区    /* not found */    return RT_NULL;//返回未找到}

查找线程是通过内核对象管理系统来查找的，根据内核对象的类型，找到相应内核对象链表，并遍历它，比较名字，如果找到则返回。

需要注意的是，这里的进入临界区的功能只是让调度器暂时停止工作，即停止调度线程，而退出临界区则是让停止工作的调度器重新恢复工作。这样做的理由是防止临界区内的执行调度器终止，切换到其它线程去了。