, i5 W8 x; A- z8 R* K【RT-Thread内核实现与应用开发实战指南】本书总共分为两个部分，第一部分主要剖析 RT-Thread 内核的实现机理，通过代码从操作系统最基本的线程创建和线程切换开始，一步一步增加代码功能（线程阻塞、时间片、优先级、临界区等）
9 f( K$ ?. Z6 B由浅入深从开发者的角度教读者怎么从零实现基本的操作系统内核。虽然内容不是很细致，但是能够帮助读者抓住重点，
1 S# `/ N" j  ~! x6 `1 D9 p让读者能够最快速的了解操作系统的核心，读完这部分然后再去阅读源码会比直接阅读源码事半功倍。第二部分内容着重
RT-Thread 的应用，分别介绍操作系统各种机制（信号量、互斥量、时间、邮箱等）的工作机理以及相关的接口函数，读者
可以通过这部分去熟悉 RT-Thread 的应用。

由于本人之前对一些操作系统（FreeRTOS）也有所学习和应用，但是没有深入去学习源码，对于操作系统内核的实现机制
并不是很了解，因此这次也将学习重点放在第一部分，下面针对第一部分的线程创建和切换这部分进行总结。
5 M$ G7 F5 r( R( E
对于操作系统而言，线程是最基本的概念，什么是线程呢？线程是程序执行的最小单元，每个线程都拥有独立的栈空间
7 C6 ^) Z; q8 z，是系统调度的基本单元。操作系统最核心的地方也在于线程的调度，系统为了方便线程调度，为每个线程都额外定义了
' B' J0 @4 W$ r2 f7 [线程控制块，线程控制块的定义如下：
" D* k& m: a9 A' t4 h: m( \- i

1. /**
   
2. * Thread structure
   & l- p7 @& {+ i5 f
3. */
   
4. struct rt_thread
   & a% W2 G4 N6 G; U* v. n& {9 @2 H! s
5. {
   
6.     /* rt object */
   
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.     rt_list_t   list;                                   /**< the object list */
    8 o9 W1 N6 B6 W
12.     rt_list_t   tlist;                                  /**< the thread list */
    . C* d, M+ o% X2 k+ ?
13. 
    
14.     /* stack point and entry */
    - [  ~5 K2 O; O7 {- p
15.     void       *sp;                                     /**< stack point */
    ( ]) u: j& k* [
16.     void       *entry;                                  /**< entry */
    
17.     void       *parameter;                              /**< parameter */
    8 l: J: m+ N# }* L  s  F. B
18.     void       *stack_addr;                             /**< stack address */
    2 }) ^  Z+ I7 I2 k
19.     rt_uint32_t stack_size;                             /**< stack size */
    3 Y1 {. m! m+ ~1 r6 Q
20. 
    7 P4 o! J$ K5 J9 o3 w# s3 B- }
21.     /* error code */
    9 Z0 K, B7 Z7 g0 `1 a- r
22.     rt_err_t    error;                                  /**< error code */
    7 X6 t0 Y7 L! v$ f
23. 
    
24.     rt_uint8_t  stat;                                   /**< thread status */
    4 ~1 B8 \& F; v+ W0 `, E
25. 
    2 \" B( E( q- p- R( d" [3 C$ O
26.     /* priority */
    
27.     rt_uint8_t  current_priority;                       /**< current priority */
    
28.     rt_uint8_t  init_priority;                          /**< initialized priority */

复制代码

其中 tlist 成员是线程的链表节点，后面要把线程插入到各种双向链表中便是通过该链表节点实现，该链表节点定义如下：

1. struct rt_list_node
   
2. {
   
3.     struct rt_list_node *next;                          /**< point to next node. */
   3 q3 F; s2 J! R2 z4 w
4.     struct rt_list_node *prev;                          /**< point to prev node. */
   
5. };
   
6. typedef struct rt_list_node rt_list_t;                  /**< Type for lists. */

复制代码

线程初始化通过函数 rt_thread_init(struct rt_thread *thread) 实现，主要进行线程控制块相关成员的初始化以及初始化线程栈
具体实现如下所示：

1. static rt_err_t _rt_thread_init(struct rt_thread *thread,
   
2.                                 const char       *name,
   
3.                                 void (*entry)(void *parameter),
   
4.                                 void             *parameter,
   * ^. ~9 I: r( z5 X% V6 B4 P
5.                                 void             *stack_start,
     U' K) E& Z/ q$ b! o3 Q7 M
6.                                 rt_uint32_t       stack_size,
   
7.                                 rt_uint8_t        priority,
   $ ?9 z- w) v6 ?# C: W
8.                                 rt_uint32_t       tick)
   2 J( E* I% f4 M% q# W7 k. z' S
9. {
   ! ]0 }) \1 ~# `; E
10.     /* init thread list */
    0 F1 D& f/ s' A" V& c; C/ i$ Q2 |
11.     rt_list_init(&(thread->tlist));
    
12. 
    7 x5 Z& K4 L7 D7 N0 o7 a% |8 j
13.     thread->entry = (void *)entry;
    
14.     thread->parameter = parameter;
    
15. 
    
16.     /* stack init */
    
17.     thread->stack_addr = stack_start;
    
18.     thread->stack_size = stack_size;
    
19. 
    & u8 q& ~+ z( _& c) z& T1 l
20.     /* init thread stack */
    9 V! T! J: w7 P* g  Z) ?$ s3 o
21.     rt_memset(thread->stack_addr, '#', thread->stack_size);
    
22.     thread->sp = (void *)rt_hw_stack_init(thread->entry, thread->parameter,
    . O% T7 [2 W6 f5 G1 Q. s- e
23.                                           (void *)((char *)thread->stack_addr + thread->stack_size - 4),
    1 W: d8 _3 Y  |* f7 L& m3 u5 p
24.                                           (void *)rt_thread_exit);
    
25. 
    
26.     /* priority init */
    * L  K/ x4 B# D, Y' o/ [: p
27.     RT_ASSERT(priority < RT_THREAD_PRIORITY_MAX);
    3 q  g3 O* f' Z: e" O$ N
28.     thread->init_priority    = priority;
    0 {* c8 Q; @  C+ l7 T
29.     thread->current_priority = priority;
    
30. 
    ! C5 D- K: [& ~/ c4 `. U, e- z' p
31.     thread->number_mask = 0;
    
32. 
    
33.     /* tick init */
    6 k3 n) Z6 W- g/ I3 s, }2 t5 B
34.     thread->init_tick      = tick;
    : g( w4 |1 J# \
35.     thread->remaining_tick = tick;
    $ y. L. [$ L& T& H+ N/ R
36. 
    
37.     /* error and flags */
    ! Z6 l2 }1 I* u# F
38.     thread->error = RT_EOK;
    
39.     thread->stat  = RT_THREAD_INIT;
    + X3 {! j+ A9 _6 W4 N- f
40. 
    4 r% h, F" u6 ]) _, m) H# L
41.     /* initialize cleanup function and user data */
    
42.     thread->cleanup   = 0;
      S. ?: X* l$ e6 k. ~
43.     thread->user_data = 0;
    
44. 
    4 p: H: m  H8 I2 T# m1 [" x
45.     /* init thread timer */
    
46.     rt_timer_init(&(thread->thread_timer),
    
47.                   thread->name,
    / v5 J5 d. Q! u  C5 E2 c
48.                   rt_thread_timeout,
    
49.                   thread,
    9 W" g# ?  q3 }
50.                   0,
    4 X+ X" j7 r1 g  r
51.                   RT_TIMER_FLAG_ONE_SHOT);
    ( ?; P9 X- a* R# G) I; ]  P. b
52. 
    : w. v% \+ o7 o% `
53.     RT_OBJECT_HOOK_CALL(rt_thread_inited_hook, (thread));
    
54. 
    4 F0 {' Y/ K; Z4 b, g
55.     return RT_EOK;
    
56. }

复制代码

从上面的函数中可以看出线程栈的初始化由函数 rt_hw_stack_init() 来完成，每个线程的栈由三部分组成：自动加载到 CPU 寄存器的部分、手动加载到 CPU 寄存器的部分以及空闲栈。如下图所示：
, M$ a* K" y" P, W! n5 L# n
! t( G* o& u) L6 i/ f  q初始化后除了空闲栈部分其他值都变成 0xdeadbeef，线程第一次运行时，自动加载到 CPU 部分的内容要预先设置好，
/ V! ]) u  i, O+ h包括 PC 指针、R0任务形参，其它设置为 0。
线程初始化后要插入到就绪列表中，通过函数 rt_list_insert_before() 实现，最后要运行线程则需要启动调度器，
% V+ |$ f9 I# O3 x- t3 u" g7 X1 |. R启用调度器通过函数 rt_system_scheduler_start() 实现，具体函数实现如下：
9 O7 @+ k1 [: H/ J$ W3 j) i

1. <blockquote>void rt_system_scheduler_start(void)

复制代码

函数中 rt_hw_context_switch_to() 用于启动第一次线程切换，该函数通过触发 PendSV 中断来实现上下文切换，后面的
上下文切换则通过函数 rt_hw_context_switch() 实现。最后系统调度通过 rt_scheduer() 函数实现，其核心内容也是通过
& O- Q7 ?: u( C2 g" V: L3 i获取下一个要执行的线程然后产生上下文切换，在此不详细说明。


第一次分享帖子，写得不好多多见谅。帖子内容有限，只是说明一下我个人对于其中的一点理解，各位有兴趣的还是得亲
自去看书，个人觉得书是挺好的，由浅入深，循序渐进，但是看完书后最重要的还是得多实践，要想深入内核原理的还得
2 c& A( `$ C/ d/ ?慢慢啃源码。