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;//返回未找到
}

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

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