【RT-Thread内核实现与应用开发实战指南】本书总共分为两个部分，第一部分主要剖析 RT-Thread 内核的实现机理，通过代码从操作系统最基本的线程创建和线程切换开始，一步一步增加代码功能（线程阻塞、时间片、优先级、临界区等）
# ?! M1 @+ F/ D  ?4 n; }由浅入深从开发者的角度教读者怎么从零实现基本的操作系统内核。虽然内容不是很细致，但是能够帮助读者抓住重点，
* |) N8 E% D0 T, S( Q# W让读者能够最快速的了解操作系统的核心，读完这部分然后再去阅读源码会比直接阅读源码事半功倍。第二部分内容着重
RT-Thread 的应用，分别介绍操作系统各种机制（信号量、互斥量、时间、邮箱等）的工作机理以及相关的接口函数，读者
可以通过这部分去熟悉 RT-Thread 的应用。
- q. ?. Y8 w' r+ S# E
* F( f- I+ f# U4 n% R/ Y, @由于本人之前对一些操作系统（FreeRTOS）也有所学习和应用，但是没有深入去学习源码，对于操作系统内核的实现机制
并不是很了解，因此这次也将学习重点放在第一部分，下面针对第一部分的线程创建和切换这部分进行总结。
( @- d+ J, j5 l% Z$ ~, G3 ?' k
对于操作系统而言，线程是最基本的概念，什么是线程呢？线程是程序执行的最小单元，每个线程都拥有独立的栈空间
# n9 d5 K# G. e，是系统调度的基本单元。操作系统最核心的地方也在于线程的调度，系统为了方便线程调度，为每个线程都额外定义了
线程控制块，线程控制块的定义如下：

1. /**
   
2. * Thread structure
   . T# |- B% w( Y0 J$ y1 V: _, n
3. */
   
4. struct rt_thread
   
5. {
   ' b' {$ c+ h1 |
6.     /* rt object */
   
7.     char        name[RT_NAME_MAX];                      /**< the name of thread */
   0 n+ _& `, `: H1 d
8.     rt_uint8_t  type;                                   /**< type of object */
   
9.     rt_uint8_t  flags;                                  /**< thread's flags */
   
10. 
    . r8 ~; n3 U1 V8 t0 l3 \
11.     rt_list_t   list;                                   /**< the object list */
    
12.     rt_list_t   tlist;                                  /**< the thread list */
    
13. 
    / O! [$ b/ w3 C0 @) D& _# @$ v& b
14.     /* stack point and entry */
    # l, m$ }7 P( s: f' D+ g8 X: L9 F
15.     void       *sp;                                     /**< stack point */
    9 n* m* b0 U4 q* e4 i
16.     void       *entry;                                  /**< entry */
    
17.     void       *parameter;                              /**< parameter */
    
18.     void       *stack_addr;                             /**< stack address */
    ) {4 k" T+ J' r; B
19.     rt_uint32_t stack_size;                             /**< stack size */
    
20. 
    
21.     /* error code */
    + S6 ~1 `' y. ~5 E
22.     rt_err_t    error;                                  /**< error code */
    
23. 
    
24.     rt_uint8_t  stat;                                   /**< thread status */
    
25. 
    
26.     /* priority */
    6 e  M) n! z0 ~$ }+ ]3 W
27.     rt_uint8_t  current_priority;                       /**< current priority */
    
28.     rt_uint8_t  init_priority;                          /**< initialized priority */

复制代码

其中 tlist 成员是线程的链表节点，后面要把线程插入到各种双向链表中便是通过该链表节点实现，该链表节点定义如下：
2 n: A, E; H% q& ~* |9 n; _2 o- j! c

1. struct rt_list_node
   3 a8 s) V7 x3 k; }. t
2. {
   % y7 Z; c1 @9 X6 c  w
3.     struct rt_list_node *next;                          /**< point to next node. */
   4 z3 F+ J& N- \2 r
4.     struct rt_list_node *prev;                          /**< point to prev node. */
   ! v" a1 ^; R* q; D0 j
5. };
   
6. typedef struct rt_list_node rt_list_t;                  /**< Type for lists. */

复制代码

线程初始化通过函数 rt_thread_init(struct rt_thread *thread) 实现，主要进行线程控制块相关成员的初始化以及初始化线程栈
" |# G' c! F& L) U; L3 B具体实现如下所示：
% ]3 |6 g! C7 Y9 I

1. static rt_err_t _rt_thread_init(struct rt_thread *thread,
   
2.                                 const char       *name,
   
3.                                 void (*entry)(void *parameter),
   ( A! q" Y8 c1 P2 w! ?; X4 {
4.                                 void             *parameter,
   # z% Q4 P9 Q, `2 O% ^. ^
5.                                 void             *stack_start,
   % c9 p: H7 e6 R; @
6.                                 rt_uint32_t       stack_size,
   
7.                                 rt_uint8_t        priority,
   / G4 i+ H' h$ _- a
8.                                 rt_uint32_t       tick)
   
9. {
   1 |0 |2 B7 c7 ]/ k7 }5 m2 F
10.     /* init thread list */
    . P) ^% b7 [" G# @, ?
11.     rt_list_init(&(thread->tlist));
    
12. 
    . h$ X. }. Y; L9 D! [% C9 }/ R
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. 
    $ B6 l6 A& L1 a  a+ `, E
20.     /* init thread stack */
    : R# \. q- L. O7 k
21.     rt_memset(thread->stack_addr, '#', thread->stack_size);
    ; b# A  Q* P) M
22.     thread->sp = (void *)rt_hw_stack_init(thread->entry, thread->parameter,
    1 y+ g4 d4 s- j# f% _
23.                                           (void *)((char *)thread->stack_addr + thread->stack_size - 4),
    ; a' `2 ]  D& e& s9 h9 D6 C
24.                                           (void *)rt_thread_exit);
    
25. 
    0 J5 m. P# y) h! Y) @
26.     /* priority init */
    8 Z% {6 ~$ m) s0 d( B& X
27.     RT_ASSERT(priority < RT_THREAD_PRIORITY_MAX);
    
28.     thread->init_priority    = priority;
    
29.     thread->current_priority = priority;
    & W8 k, u' P6 D# a8 X
30. 
    
31.     thread->number_mask = 0;
    
32. 
    
33.     /* tick init */
    
34.     thread->init_tick      = tick;
    $ h7 K: F0 S: V
35.     thread->remaining_tick = tick;
    $ s1 K" q: [# J
36. 
    3 W6 g) n* T/ I) f* `& ]" O
37.     /* error and flags */
    
38.     thread->error = RT_EOK;
    / I; W$ z' I( f
39.     thread->stat  = RT_THREAD_INIT;
    
40. 
    ) L# s* s0 G( J% z
41.     /* initialize cleanup function and user data */
    9 Z" E- q9 {' v' V# `( Y1 N0 B
42.     thread->cleanup   = 0;
    ( [* S; C6 u1 h/ J. y
43.     thread->user_data = 0;
    
44. 
    8 j' q- H( c$ o8 @7 `
45.     /* init thread timer */
    
46.     rt_timer_init(&(thread->thread_timer),
    
47.                   thread->name,
    
48.                   rt_thread_timeout,
    
49.                   thread,
    ( c7 F% G3 j& A/ m
50.                   0,
    5 P, s, |, O* b1 ?' w( ~$ q
51.                   RT_TIMER_FLAG_ONE_SHOT);
    
52. 
    ( D' @' C: |7 Z( u) e' P5 D
53.     RT_OBJECT_HOOK_CALL(rt_thread_inited_hook, (thread));
    
54. 
    $ c( ~+ b4 S$ e- v  A* R& a3 I
55.     return RT_EOK;
    2 P6 _  B' y) v0 X/ M( h+ [) S
56. }

复制代码

从上面的函数中可以看出线程栈的初始化由函数 rt_hw_stack_init() 来完成，每个线程的栈由三部分组成：自动加载到 CPU 寄存器的部分、手动加载到 CPU 寄存器的部分以及空闲栈。如下图所示：
( R& p9 t8 i0 j/ B3 v4 j$ E7 S
初始化后除了空闲栈部分其他值都变成 0xdeadbeef，线程第一次运行时，自动加载到 CPU 部分的内容要预先设置好，
( k- f$ ~8 j' P4 ^+ l4 V) @包括 PC 指针、R0任务形参，其它设置为 0。
" c4 p% V7 C# y& D+ G4 s线程初始化后要插入到就绪列表中，通过函数 rt_list_insert_before() 实现，最后要运行线程则需要启动调度器，
启用调度器通过函数 rt_system_scheduler_start() 实现，具体函数实现如下：
4 c# C5 v- V& e% W+ \

1. <blockquote>void rt_system_scheduler_start(void)

复制代码

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


第一次分享帖子，写得不好多多见谅。帖子内容有限，只是说明一下我个人对于其中的一点理解，各位有兴趣的还是得亲
! O1 ~7 W" t0 R* ~) u# H9 m7 B自去看书，个人觉得书是挺好的，由浅入深，循序渐进，但是看完书后最重要的还是得多实践，要想深入内核原理的还得
慢慢啃源码。

; T( l7 l- |, w$ y' G8 N, w