rt-thread线程源码分析

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

1 线程控制块的数据结构

[cpp]  view plain  copy

1. /** 
2.  * Thread structure 
3.  */  
4. struct rt_thread  
5. {  
6.     /* rt object *///这里就是rt_object的结构,其实也可以用rt_object parent来定义，估计线程在早些时候并没有这么做，后来也就没改过来  
7.     char        name[RT_NAME_MAX];                      /**< the name of thread */  
8.     rt_uint8_t  type;                                   /**< type of object */  
9.     rt_uint8_t  flags;                                  /**< thread's flags */  
10.       
11. #ifdef RT_USING_MODULE//模块ID  
12.     void       *module_id;                              /**< id of application module */  
13. #endif  
14.     //内核对象链表  
15.     rt_list_t   list;                                   /**< the object list */  
16.     rt_list_t   tlist;                                  /**< the thread list *///线程链表,一般用作就绪队列元素节点  
17.   
18.     /* stack point and entry */  
19.     void       *sp;                                     /**< stack point *///栈指针  
20.     void       *entry;                                  /**< entry *///入口函数  
21.     void       *parameter;                              /**< parameter *///入口函数对应的参数  
22.     void       *stack_addr;                             /**< stack address *///栈地址  
23.     rt_uint16_t stack_size;                             /**< stack size *///栈大小  
24.   
25.     /* error code */  
26.     rt_err_t    error;                                  /**< error code *///错误代码,用于IPC机制中，标志是否已经获取成功  
27.   
28.     rt_uint8_t  stat;                                   /**< thread stat *///线程的当前状态  
29.   
30.     /* priority */  
31.     rt_uint8_t  current_priority;                       /**< current priority *///当前优先级  
32.     rt_uint8_t  init_priority;                          /**< initialized priority *///初始优先级  
33. #if RT_THREAD_PRIORITY_MAX > 32  
34.     rt_uint8_t  number;  
35.     rt_uint8_t  high_mask;  
36. #endif  
37.     rt_uint32_t number_mask;  
38.   
39. #if defined(RT_USING_EVENT)//与IPC机制事件相关的一些参数  
40.     /* thread event */  
41.     rt_uint32_t event_set; //此线程接收到的事件  
42.     rt_uint8_t  event_info;//此线程的事件过滤信息,用于过滤事件,只保留感兴趣的事件  
43. #endif  
44.   
45.     rt_ubase_t  init_tick;                              /**< thread's initialized tick *///初始tick  
46.     rt_ubase_t  remaining_tick;                         /**< remaining tick *///剩余tick  
47.   
48.     struct rt_timer thread_timer;                       /**< built-in thread timer *///线程定时器  
49.   
50.     void (*cleanup)(struct rt_thread *tid);             /**< cleanup function when thread exit *///相当于线程的析构函数，用于销毁线程时做些后续操作  
51.   
52.     rt_uint32_t user_data;                              /**< private user data beyond this thread *///析构函数的输入参数  
53. };  
54. 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 初始化线程

[cpp]  view plain  copy

1. /*@{*/  
2.   
3. /** 
4.  * This function will initialize a thread, normally it's used to initialize a 
5.  * static thread object. 
6.  * 
7.  * @param thread the static thread object 
8.  * @param name the name of thread, which shall be unique 
9.  * @param entry the entry function of thread 
10.  * @param parameter the parameter of thread enter function 
11.  * @param stack_start the start address of thread stack 
12.  * @param stack_size the size of thread stack 
13.  * @param priority the priority of thread 
14.  * @param tick the time slice if there are same priority thread 
15.  * 
16.  * @return the operation status, RT_EOK on OK, -RT_ERROR on error 
17.  */  
18. rt_err_t rt_thread_init(struct rt_thread *thread,  
19.                         const char       *name,  
20.                         void (*entry)(void *parameter),  
21.                         void             *parameter,  
22.                         void             *stack_start,  
23.                         rt_uint32_t       stack_size,  
24.                         rt_uint8_t        priority,  
25.                         rt_uint32_t       tick)  
26. {  
27.     /* thread check *///参数检查  
28.     RT_ASSERT(thread != RT_NULL);  
29.     RT_ASSERT(stack_start != RT_NULL);  
30.   
31.     /* init thread object */  
32.     rt_object_init((rt_object_t)thread, RT_Object_Class_Thread, name);//初始化内核对象  
33.   
34.     return _rt_thread_init(thread,  
35.                            name,  
36.                            entry,  
37.                            parameter,  
38.                            stack_start,  
39.                            stack_size,  
40.                            priority,  
41.                            tick);  
42. }  

其中_rt_thread_init的函数如下定义:

[cpp]  view plain  copy

1. static rt_err_t _rt_thread_init(struct rt_thread *thread,  
2.                                 const char       *name,  
3.                                 void (*entry)(void *parameter),  
4.                                 void             *parameter,  
5.                                 void             *stack_start,  
6.                                 rt_uint32_t       stack_size,  
7.                                 rt_uint8_t        priority,  
8.                                 rt_uint32_t       tick)  
9. {  
10.     /* init thread list */  
11.     rt_list_init(&(thread->tlist));//初始化线程节点  
12.   
13.     thread->entry = (void *)entry;//入口函数  
14.     thread->parameter = parameter;//入口函数的参数  
15.   
16.     /* stack init */  
17.     thread->stack_addr = stack_start;//栈地址  
18.     thread->stack_size = (rt_uint16_t)stack_size;//栈大小  
19.   
20.     /* init thread stack */  
21.     rt_memset(thread->stack_addr, '#', thread->stack_size);//将栈内的所有字节初始化为'#'号  
22.     thread->sp = (void *)rt_hw_stack_init(thread->entry, thread->parameter,//初始化时设置sp的内容，rt_hw_stack_init是一个与具体MCU相关的函数，这里就不做介绍  
23.         (void *)((char *)thread->stack_addr + thread->stack_size - 4),  
24.         (void *)rt_thread_exit);  
25.   
26.     /* priority init */  
27.     RT_ASSERT(priority < RT_THREAD_PRIORITY_MAX);  
28.     thread->init_priority    = priority;//当前优先级和初始化优先级设置  
29.     thread->current_priority = priority;  
30.   
31.     /* tick init */  
32.     thread->init_tick      = tick;//初始化tick和剩余tick  
33.     thread->remaining_tick = tick;  
34.   
35.     /* error and flags */  
36.     thread->error = RT_EOK;//错误的状态，线程状态初始化时为RT_THREAD_INIT  
37.     thread->stat  = RT_THREAD_INIT;  
38.   
39.     /* initialize cleanup function and user data */  
40.     thread->cleanup   = 0;//线程析构函数及其参数  
41.     thread->user_data = 0;  
42.   
43.     /* init thread timer */  
44.     rt_timer_init(&(thread->thread_timer),//初始化线程的定时器  
45.                   thread->name,  
46.                   rt_thread_timeout,  
47.                   thread,  
48.                   0,  
49.                   RT_TIMER_FLAG_ONE_SHOT);  
50.   
51.     return RT_EOK;  
52. }  

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

其中rt_thread_timeout的函数如下定义:

[cpp]  view plain  copy

1. /** 
2.  * This function is the timeout function for thread, normally which is invoked 
3.  * when thread is timeout to wait some resource. 
4.  * 
5.  * @param parameter the parameter of thread timeout function 
6.  */  
7. void rt_thread_timeout(void *parameter)  
8. {  
9.     struct rt_thread *thread;  
10.   
11.     thread = (struct rt_thread *)parameter;  
12.   
13.     /* thread check */  
14.     RT_ASSERT(thread != RT_NULL);  
15.     RT_ASSERT(thread->stat == RT_THREAD_SUSPEND);  
16.   
17.     /* set error number */  
18.     thread->error = -RT_ETIMEOUT;//设置此线程的error为超时错误，这些IPC机制中非常有用，  
19.   
20.     /* remove from suspend list *///从挂起链表中移除  
21.     rt_list_remove(&(thread->tlist));  
22.   
23.     /* insert to schedule ready list */  
24.     rt_schedule_insert_thread(thread);//加入调度器  
25.   
26.     /* do schedule */  
27.     rt_schedule();//重新调度  
28. }  

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

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

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

2.2 创建线程

[cpp]  view plain  copy

1. /** 
2.  * This function will create a thread object and allocate thread object memory 
3.  * and stack. 
4.  * 
5.  * @param name the name of thread, which shall be unique 
6.  * @param entry the entry function of thread 
7.  * @param parameter the parameter of thread enter function 
8.  * @param stack_size the size of thread stack 
9.  * @param priority the priority of thread 
10.  * @param tick the time slice if there are same priority thread 
11.  * 
12.  * @return the created thread object 
13.  */  
14. rt_thread_t rt_thread_create(const char *name,  
15.                              void (*entry)(void *parameter),  
16.                              void       *parameter,  
17.                              rt_uint32_t stack_size,  
18.                              rt_uint8_t  priority,  
19.                              rt_uint32_t tick)  
20. {  
21.     struct rt_thread *thread;  
22.     void *stack_start;  
23.   
24.     thread = (struct rt_thread *)rt_object_allocate(RT_Object_Class_Thread,//动态分配一个内核对象  
25.                                                     name);  
26.     if (thread == RT_NULL)  
27.         return RT_NULL;  
28.   
29.     stack_start = (void *)rt_malloc(stack_size);//动态分配一个线程栈  
30.     if (stack_start == RT_NULL)  
31.     {  
32.         /* allocate stack failure */  
33.         rt_object_delete((rt_object_t)thread);  
34.   
35.         return RT_NULL;  
36.     }  
37.   
38.     _rt_thread_init(thread,//初始化线程  
39.                     name,  
40.                     entry,  
41.                     parameter,  
42.                     stack_start,  
43.                     stack_size,  
44.                     priority,  
45.                     tick);  
46.   
47.     return thread;  
48. }  

3 线程的脱离及删除

3.1 脱离线程

[cpp]  view plain  copy

1. /** 
2.  * This function will detach a thread. The thread object will be removed from 
3.  * thread queue and detached/deleted from system object management. 
4.  * 
5.  * @param thread the thread to be deleted 
6.  * 
7.  * @return the operation status, RT_EOK on OK, -RT_ERROR on error 
8.  */  
9. rt_err_t rt_thread_detach(rt_thread_t thread)  
10. {  
11.     rt_base_t lock;  
12.   
13.     /* thread check */  
14.     RT_ASSERT(thread != RT_NULL);  
15.   
16.     /* remove from schedule */  
17.     rt_schedule_remove_thread(thread);//将线程从调度器中移除  
18.   
19.     /* release thread timer */  
20.     rt_timer_detach(&(thread->thread_timer));//脱离定时器  
21.   
22.     /* change stat */  
23.     thread->stat = RT_THREAD_CLOSE;//将线程的状态设置为RT_THREAD_CLOSE  
24.   
25.     /* detach object */  
26.     rt_object_detach((rt_object_t)thread);//脱离内核对象  
27.   
28.     if (thread->cleanup != RT_NULL)//如果存在线程析构函数  
29.     {  
30.         /* disable interrupt */  
31.         lock = rt_hw_interrupt_disable();//关中断  
32.   
33.         /* insert to defunct thread list *///rt_thread_defunct链表在系统空闲时将被空闲线程来处理  
34.         rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));//将线程加入到rt_thread_defunct链表中  
35.   
36.         /* enable interrupt */  
37.         rt_hw_interrupt_enable(lock);//开中断  
38.     }  
39.   
40.     return RT_EOK;  
41. }  

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

3.2 删除线程

[cpp]  view plain  copy

1. /** 
2.  * This function will delete a thread. The thread object will be removed from 
3.  * thread queue and detached/deleted from system object management. 
4.  * 
5.  * @param thread the thread to be deleted 
6.  * 
7.  * @return the operation status, RT_EOK on OK, -RT_ERROR on error 
8.  */  
9. rt_err_t rt_thread_delete(rt_thread_t thread)  
10. {  
11.     rt_base_t lock;  
12.   
13.     /* thread check */  
14.     RT_ASSERT(thread != RT_NULL);  
15.   
16.     /* remove from schedule */  
17.     rt_schedule_remove_thread(thread);//从调度器中移除线程  
18.   
19.     /* release thread timer */  
20.     rt_timer_detach(&(thread->thread_timer));//脱离定时器  
21.   
22.     /* change stat */  
23.     thread->stat = RT_THREAD_CLOSE;//线程状态设置为RT_THREAD_CLOSE  
24.   
25.     /* disable interrupt */  
26.     lock = rt_hw_interrupt_disable();//关中断  
27.   
28.     /* insert to defunct thread list */  
29.     rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));//将当前线程加入到空闲时才会处理的链表中  
30.   
31.     /* enable interrupt */  
32.     rt_hw_interrupt_enable(lock);//开中断  
33.   
34.     return RT_EOK;  
35. }  

4 启动线程

[cpp]  view plain  copy

1. /** 
2.  * This function will start a thread and put it to system ready queue 
3.  * 
4.  * @param thread the thread to be started 
5.  * 
6.  * @return the operation status, RT_EOK on OK, -RT_ERROR on error 
7.  */  
8. rt_err_t rt_thread_startup(rt_thread_t thread)  
9. {  
10.     /* thread check *///参数检查  
11.     RT_ASSERT(thread != RT_NULL);  
12.     RT_ASSERT(thread->stat == RT_THREAD_INIT);  
13.   
14.     /* set current priority to init priority */  
15.     thread->current_priority = thread->init_priority;//启动线程时将线程当前的优先级设置为初始优先级  
16.   
17.     /* calculate priority attribute */  
18. #if RT_THREAD_PRIORITY_MAX > 32  
19.     thread->number      = thread->current_priority >> 3;            /* 5bit */  
20.     thread->number_mask = 1L << thread->number;  
21.     thread->high_mask   = 1L << (thread->current_priority & 0x07);  /* 3bit */  
22. #else  
23.     thread->number_mask = 1L << thread->current_priority;  
24. #endif  
25.   
26.     RT_DEBUG_LOG(RT_DEBUG_THREAD, ("startup a thread:%s with priority:%d\n",  
27.                                    thread->name, thread->init_priority));  
28.     /* change thread stat */  
29.     thread->stat = RT_THREAD_SUSPEND;//将线程的状态设置为RT_THREAD_SUSPEND  
30.     /* then resume it */  
31.     rt_thread_resume(thread);//还原线程  
32.     if (rt_thread_self() != RT_NULL)//如果当前的线程不为空,则执行线程调度操作  
33.     {  
34.         /* do a scheduling */  
35.         rt_schedule();  
36.     }  
37.   
38.     return RT_EOK;  
39. }  

由此可见，启动线程时，首先会将线程设置为挂起状态，然后再唤醒它。

其中rt_thread_self函数为获取当前线程，其源码如下定义:

[cpp]  view plain  copy

1. /** 
2.  * This function will return self thread object 
3.  * 
4.  * @return the self thread object 
5.  */  
6. rt_thread_t rt_thread_self(void)  
7. {  
8.     return rt_current_thread;  
9. }  

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

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

5 线程挂起

[cpp]  view plain  copy

1. /** 
2.  * This function will suspend the specified thread. 
3.  * 
4.  * @param thread the thread to be suspended 
5.  * 
6.  * @return the operation status, RT_EOK on OK, -RT_ERROR on error 
7.  * 
8.  * @note if suspend self thread, after this function call, the 
9.  * rt_schedule() must be invoked. 
10.  */  
11. rt_err_t rt_thread_suspend(rt_thread_t thread)  
12. {  
13.     register rt_base_t temp;  
14.   
15.     /* thread check */  
16.     RT_ASSERT(thread != RT_NULL);  
17.   
18.     RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread suspend:  %s\n", thread->name));  
19.   
20.     if (thread->stat != RT_THREAD_READY)//此函数只对处于就绪状态的线程操作  
21.     {  
22.         RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread suspend: thread disorder, %d\n",  
23.                                        thread->stat));  
24.           
25.         return -RT_ERROR;  
26.     }  
27.   
28.     /* disable interrupt */  
29.     temp = rt_hw_interrupt_disable();//关中断  
30.   
31.     /* change thread stat */  
32.     thread->stat = RT_THREAD_SUSPEND;//将线程设置为挂起状态  
33.     rt_schedule_remove_thread(thread);//将线程从调试器中移除  
34.   
35.     /* enable interrupt */  
36.     rt_hw_interrupt_enable(temp);//开中断  
37.   
38.     return RT_EOK;  
39. }  

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

此函数比较简单。

6 线程唤醒

[cpp]  view plain  copy

1. /** 
2.  * This function will resume a thread and put it to system ready queue. 
3.  * 
4.  * @param thread the thread to be resumed 
5.  * 
6.  * @return the operation status, RT_EOK on OK, -RT_ERROR on error 
7.  */  
8. rt_err_t rt_thread_resume(rt_thread_t thread)  
9. {  
10.     register rt_base_t temp;  
11.   
12.     /* thread check */  
13.     RT_ASSERT(thread != RT_NULL);  
14.   
15.     RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread resume:  %s\n", thread->name));  
16.   
17.     if (thread->stat != RT_THREAD_SUSPEND)//只对处于挂起的线程进行还原操作  
18.     {  
19.         RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread resume: thread disorder, %d\n",  
20.                                        thread->stat));  
21.   
22.         return -RT_ERROR;  
23.     }  
24.   
25.     /* disable interrupt */  
26.     temp = rt_hw_interrupt_disable();//关中断  
27.   
28.     /* remove from suspend list */  
29.     rt_list_remove(&(thread->tlist));//从挂起队列中移除  
30.   
31.     /* remove thread timer */  
32.     rt_list_remove(&(thread->thread_timer.list));//因线程即将运行，所以需要移除定时器，无需再定时  
33.   
34.     /* change timer state */  
35.     thread->thread_timer.parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;//将内核对象的标志设置为定时器非激活标志  
36.   
37.     /* enable interrupt */  
38.     rt_hw_interrupt_enable(temp);//开中断  
39.   
40.     /* insert to schedule ready list */  
41.     rt_schedule_insert_thread(thread);//将线程加入调度器  
42.   
43.     return RT_EOK;  
44. }  

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

7 线程让出处理机

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

[cpp]  view plain  copy

1. /** 
2.  * This function will let current thread yield processor, and scheduler will 
3.  * choose a highest thread to run. After yield processor, the current thread 
4.  * is still in READY state. 
5.  * 
6.  * @return RT_EOK 
7.  */  
8. rt_err_t rt_thread_yield(void)  
9. {  
10.     register rt_base_t level;  
11.     struct rt_thread *thread;  
12.   
13.     /* disable interrupt */  
14.     level = rt_hw_interrupt_disable();//关中断  
15.   
16.     /* set to current thread */  
17.     thread = rt_current_thread;//得到当前线程  
18.   
19.     /* if the thread stat is READY and on ready queue list */  
20.     if (thread->stat == RT_THREAD_READY &&//如果当前线程处于就绪状态且在就绪队列  
21.         thread->tlist.next != thread->tlist.prev)  
22.     {  
23.         /* remove thread from thread list */  
24.         rt_list_remove(&(thread->tlist));//从就绪队列中移除当前线程  
25.   
26.         /* put thread to end of ready queue */  
27.         rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]),//加入到就绪队列末尾  
28.                               &(thread->tlist));  
29.   
30.         /* enable interrupt */  
31.         rt_hw_interrupt_enable(level);//开中断  
32.   
33.         rt_schedule();//重新调度线程  
34.   
35.         return RT_EOK;  
36.     }  
37.   
38.     /* enable interrupt */  
39.     rt_hw_interrupt_enable(level);//开中断  
40.   
41.     return RT_EOK;  
42. }  

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

8 线程睡眠

[cpp]  view plain  copy

1. /** 
2.  * This function will let current thread sleep for some ticks. 
3.  * 
4.  * @param tick the sleep ticks 
5.  * 
6.  * @return RT_EOK 
7.  */  
8. rt_err_t rt_thread_sleep(rt_tick_t tick)  
9. {  
10.     register rt_base_t temp;  
11.     struct rt_thread *thread;  
12.   
13.     /* disable interrupt */  
14.     temp = rt_hw_interrupt_disable();//关中断  
15.     /* set to current thread */  
16.     thread = rt_current_thread;//得到当前线程  
17.     RT_ASSERT(thread != RT_NULL);  
18.   
19.     /* suspend thread */  
20.     rt_thread_suspend(thread);//挂起当前线程  
21.   
22.     /* reset the timeout of thread timer and start it */  
23.     rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &tick);//设置定时器  
24.     rt_timer_start(&(thread->thread_timer));//启动定时器  
25.   
26.     /* enable interrupt */  
27.     rt_hw_interrupt_enable(temp);//开中断  
28.   
29.     rt_schedule();//启动调度器  
30.   
31.     /* clear error number of this thread to RT_EOK */  
32.     if (thread->error == -RT_ETIMEOUT)//将当前线程的错误码设置为超时  
33.         thread->error = RT_EOK;  
34.   
35.     return RT_EOK;  
36. }  

[cpp]  view plain  copy

1. /** 
2.  * This function will let current thread delay for some ticks. 
3.  * 
4.  * @param tick the delay ticks 
5.  * 
6.  * @return RT_EOK 
7.  */  
8. rt_err_t rt_thread_delay(rt_tick_t tick)  
9. {  
10.     return rt_thread_sleep(tick);  
11. }  

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

9 线程控制

[cpp]  view plain  copy

1. /** 
2.  * This function will control thread behaviors according to control command. 
3.  * 
4.  * @param thread the specified thread to be controlled 
5.  * @param cmd the control command, which includes 
6.  *  RT_THREAD_CTRL_CHANGE_PRIORITY for changing priority level of thread; 
7.  *  RT_THREAD_CTRL_STARTUP for starting a thread; 
8.  *  RT_THREAD_CTRL_CLOSE for delete a thread. 
9.  * @param arg the argument of control command 
10.  * 
11.  * @return RT_EOK 
12.  */  
13. rt_err_t rt_thread_control(rt_thread_t thread, rt_uint8_t cmd, void *arg)  
14. {  
15.     register rt_base_t temp;  
16.   
17.     /* thread check */  
18.     RT_ASSERT(thread != RT_NULL);  
19.   
20.     switch (cmd)  
21.     {  
22.     case RT_THREAD_CTRL_CHANGE_PRIORITY://修改优先级  
23.         /* disable interrupt */  
24.         temp = rt_hw_interrupt_disable();//关中断  
25.   
26.         /* for ready thread, change queue */  
27.         if (thread->stat == RT_THREAD_READY)//如果线程处于就绪状态  
28.         {  
29.             /* remove thread from schedule queue first */  
30.             rt_schedule_remove_thread(thread);//移除  
31.   
32.             /* change thread priority */  
33.             thread->current_priority = *(rt_uint8_t *)arg;//设置优先级  
34.   
35.             /* recalculate priority attribute */  
36. #if RT_THREAD_PRIORITY_MAX > 32  
37.             thread->number      = thread->current_priority >> 3;            /* 5bit */  
38.             thread->number_mask = 1 << thread->number;  
39.             thread->high_mask   = 1 << (thread->current_priority & 0x07);   /* 3bit */  
40. #else  
41.             thread->number_mask = 1 << thread->current_priority;  
42. #endif  
43.   
44.             /* insert thread to schedule queue again */  
45.             rt_schedule_insert_thread(thread);//加入调度器  
46.         }  
47.         else  
48.         {  
49.             thread->current_priority = *(rt_uint8_t *)arg;  
50.   
51.             /* recalculate priority attribute */  
52. #if RT_THREAD_PRIORITY_MAX > 32  
53.             thread->number      = thread->current_priority >> 3;            /* 5bit */  
54.             thread->number_mask = 1 << thread->number;  
55.             thread->high_mask   = 1 << (thread->current_priority & 0x07);   /* 3bit */  
56. #else  
57.             thread->number_mask = 1 << thread->current_priority;  
58. #endif  
59.         }  
60.   
61.         /* enable interrupt */  
62.         rt_hw_interrupt_enable(temp);  
63.         break;  
64.   
65.     case RT_THREAD_CTRL_STARTUP://启动  
66.         return rt_thread_startup(thread);  
67.   
68. #ifdef RT_USING_HEAP  
69.     case RT_THREAD_CTRL_CLOSE://关闭线程  
70.         return rt_thread_delete(thread);  
71. #endif  
72.   
73.     default:  
74.         break;  
75.     }  
76.   
77.     return RT_EOK;  
78. }  

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

10 查找线程

[cpp]  view plain  copy

1. /** 
2.  * This function will find the specified thread. 
3.  * 
4.  * @param name the name of thread finding 
5.  * 
6.  * @return the found thread 
7.  * 
8.  * @note please don't invoke this function in interrupt status. 
9.  */  
10. rt_thread_t rt_thread_find(char *name)  
11. {  
12.     struct rt_object_information *information;  
13.     struct rt_object *object;  
14.     struct rt_list_node *node;  
15.   
16.     extern struct rt_object_information rt_object_container[];  
17.   
18.     /* enter critical */  
19.     if (rt_thread_self() != RT_NULL)  
20.         rt_enter_critical();//进入临界区  
21.   
22.     /* try to find device object */  
23.     information = &rt_object_container[RT_Object_Class_Thread];//从内核对象容器中获取内核对象链表  
24.     for (node  = information->object_list.next;  
25.          node != &(information->object_list);  
26.          node  = node->next)  
27.     {  
28.         object = rt_list_entry(node, struct rt_object, list);//得到内核对象  
29.         if (rt_strncmp(object->name, name, RT_NAME_MAX) == 0)//比较名字  
30.         {  
31.             /* leave critical */  
32.             if (rt_thread_self() != RT_NULL)  
33.                 rt_exit_critical();//退出临界区  
34.   
35.             return (rt_thread_t)object;//返回内核对象  
36.         }  
37.     }  
38.   
39.     /* leave critical */  
40.     if (rt_thread_self() != RT_NULL)  
41.         rt_exit_critical();//退出临界区  
42.   
43.     /* not found */  
44.     return RT_NULL;//返回未找到  
45. }  

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

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