2.线程的创建

线程的创建

​ 线程是实现任务的载体，它是RT-Thread中最基本的调度单位。在rtt中，线程由三部分组成：线程代码（入口函数），线程控制块，线程堆栈

​ 线程代码分两种：无限循环结构和顺序执行结构，在无限循环结构中需要有让出cpu使用的api

​ 线程控制块是操作系统用于管理线程的一个数据结构，他会存放线程的一些基本信息。 在rtt中线程控制块的成员如下。

struct rt_thread
{
    /* rt object */
    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
    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_uint32_t stack_size;                             /**< stack size */

    /* error code */
    rt_err_t    error;                                  /**< error code */

    rt_uint8_t  stat;                                   /**< thread status */

    /* 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)
    /* thread event */
    rt_uint32_t event_set;
    rt_uint8_t  event_info;
#endif

#if defined(RT_USING_SIGNALS)
    rt_sigset_t     sig_pending;                        /**< the pending signals */
    rt_sigset_t     sig_mask;                           /**< the mask bits of signal */

    void            *sig_ret;                           /**< the return stack pointer from signal */
    rt_sighandler_t *sig_vectors;                       /**< vectors of signal handler */
    void            *si_list;                           /**< the signal infor list */
#endif

    rt_ubase_t  init_tick;                              /**< thread's initialized tick */
    rt_ubase_t  remaining_tick;                         /**< remaining tick */

    struct rt_timer thread_timer;                       /**< built-in thread timer */

    void (*cleanup)(struct rt_thread *tid);             /**< cleanup function when thread exit */

    /* light weight process if present */
#ifdef RT_USING_LWP
    void        *lwp;
#endif

    rt_uint32_t user_data;                             /**< private user data beyond this thread */
};

​ 线程栈：rtt中每个线程都具有独立的栈空间，当进行线程切换时，系统会将当前线程的上下文保存在线程栈中，当线程要恢复运行时，再从线程栈中读取上下文信息，恢复线程的运行。线程上下文指的是线程执行时的环境。线程栈在形式上是一段连续的内存空间。

创建线程：

1.创建静态线程 rt_thread_init

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)

2.创建动态线程 rt_thread_create

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);

启动线程：

rt_err_t rt_thread_startup(rt_thread_t thread)

删除线程：

在执行完rt_thread_delete并不是真正的把线程删除，只是把线程状态改为RT_THREAD_CLOSE，在下一次执行空闲线程的时候，才会被真正删除（释放线程控制块和线程栈）

rt_err_t rt_thread_detach(rt_thread_t thread); // 删除使用 rt_thread_init()创建的线程

rt_err_t rt_thread_delete(rt_thread_t thread); // 删除使用 rt_thread_create()创建的线程

线程状态：

• 初始状态：当线程刚开始创建还没开始运行时就处于初始状态：当创建完进程，但是未调用 rt_thread_startup 使它就绪
• 就绪状态：这个线程完全准备好了，随时可以运行：只是还轮不到它,这时它就处于就绪态:
  • 创建线程后，使用 rt_thread_startup()函数使它进入就绪态。
  • 在运行过程中，被更高优先级的线程抢占了，这时它处于就绪状态
  • 在运行过程中，被更高优先级的线程抢占了，这时它处于就绪状态
  • 因为等待某些资源而没有运行，别的线程或者中断函数把它唤醒了，这时它处于就绪状态
• 运行状态：当处于就绪状态的线程运行时，它就处于运行状态
• 挂起状态：在等待一些同步事件或等待时间时，用户主动挂起，使线程等待
• 关闭状态：当线程运行结束时，将处于关闭状态
  • 可由运行状态正常退出，进入关闭状态
  • 或者通过线程删除函数进入关闭状态