RT-Thread（三）线程的创建

线程的组成

RT-Thread 中，线程由三部分组成：线程代码（入口函数）、线程控制块、线程堆栈

• 线程代码

void thread_entry(void *parameter)
{
      
       while(1)
       {
               /* 等待事件的发生*/              
                     .
                     .
               /* 处理事件*/    
      }    
}
                   无限循环结构

void thread_entry(void *parameter)
{
      
               /* 事务1处理*/  
               /* 事务2处理*/              
                     .
                     .
               /* 事务N处理*/ 
}


                   顺序执行结构

线程控制块

线程控制块是操作系统用于管理线程的一个数据结构， 它会存放线程的一些信息， 例如优先级、 线程名称、 线程状态等， 也包含线程与线程之间连接用的链表结构， 线程等待事件集合等。

struct rt_thread
struct rt_thread *rt_thread_t

线程栈

• RT-Thread 每个线程都具有独立的栈空间， 当进行线程切换时， 系统会将当前线程的上下文保存在线程栈中，
  当线程要恢复运行时，再从线程栈中读取上下文信息， 恢复线程的运行。

• 线程上下文是指线程执行时的环境，具体来说就是各个变量和数据包括所有寄存器变量、堆栈信息、内存信息等。

• 线程栈在形式上是一段连续的内存空间 ，我们可以通过定义一个数组或者申请一段动态内存来作为线程的栈。

线程创建

• 创建线程

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)

                          创建静态线程

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)

调用此函数后创建的线程会被加入到线程的就绪队列，执行调度

thread_sample.c

/*
 * Copyright (c) 2006-2018, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2018-08-24     yangjie      the first version
 */

/*
 * 程序清单：创建、初始化/脱离线程
 *
 * 这个例子会创建两个线程，一个动态线程，一个静态线程。
 * 静态线程在运行完毕后自动被系统脱离，动态线程一直打印计数。
 */
#include <rtthread.h>

#define THREAD_PRIORITY         25
#define THREAD_STACK_SIZE       512
#define THREAD_TIMESLICE        5

static rt_thread_t tid1 = RT_NULL;

/* 线程1的入口函数 */
static void thread1_entry(void *parameter)
{
    rt_uint32_t count = 0;

    while (1)
    {
        /* 线程1采用低优先级运行，一直打印计数值 */
        rt_kprintf("thread1 count: %d\n", count ++);
        rt_thread_mdelay(500);
    }
}

ALIGN(RT_ALIGN_SIZE)
static char thread2_stack[1024];
static struct rt_thread thread2;

/* 线程2入口 */
static void thread2_entry(void *param)
{
    rt_uint32_t count = 0;

    /* 线程2拥有较高的优先级，以抢占线程1而获得执行 */
    for (count = 0; count < 10 ; count++)
    {
        /* 线程2打印计数值 */
        rt_kprintf("thread2 count: %d\n", count);
    }
    rt_kprintf("thread2 exit\n");

    /* 线程2运行结束后也将自动被系统脱离 */
}

/* 线程示例 */
int thread_sample(void)
{
    /* 创建线程1，名称是thread1，入口是thread1_entry*/
    tid1 = rt_thread_create("thread1",
                            thread1_entry, RT_NULL,
                            THREAD_STACK_SIZE,
                            THREAD_PRIORITY, THREAD_TIMESLICE);

    /* 如果获得线程控制块，启动这个线程 */
    if (tid1 != RT_NULL)
        rt_thread_startup(tid1);

    /* 初始化线程2，名称是thread2，入口是thread2_entry */
    rt_thread_init(&thread2,
                   "thread2",
                   thread2_entry,
                   RT_NULL,
                   &thread2_stack[0],
                   sizeof(thread2_stack),
                   THREAD_PRIORITY - 1, THREAD_TIMESLICE);
    rt_thread_startup(&thread2);

    return 0;
}

/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(thread_sample, thread sample);