RT-THREAD 内核快速入门（一）线程

Silent Knight

已于 2022-02-12 20:00:05 修改

阅读量1.6k

点赞数 3

分类专栏： RT-THREAD 系列入门文章标签： c语言 rtos stm32

于 2022-02-10 00:07:18 首次发布

本文链接：https://blog.csdn.net/weixin_46185705/article/details/122850811

版权

RT-THREAD 系列入门专栏收录该内容

5 篇文章 6 订阅

订阅专栏

系列文章

RT-THREAD 内核快速入门（二）定时器

RT-THREAD 内核快速入门（三）信号量，互斥量，事件

RT-THREAD 内核快速入门（四）邮箱，消息队列，信号

RT-THREAD 内核快速入门（五）内存管理与中断管理

基于STM32Cubemx移植Rt-thread-nano

前言

这个系列将会从RT-thread内核将会框架和总体下手，同时给出需要注意的核心，以及内核之间的联系（官方文档没有对这些做出比较综合的解释）。函数具体用法不做讨论，自己看文档就可以了，更重要的是理解RTOS的运行方式与运行原理，以及编程需要注意的，这些重难点才是本文讨论的。理解好运行的方式与原理，其他的细节能够很快速的攻破。这里所谓的快速上手就是，理解RTOS的运行方式与运行原理，知道怎么运行了，什么运行方式会出现什么结果，RTOS优劣势，裸机与之相比又有什么优势，也就能够明确与裸机编程的区别，以及如何进行运用编程，将RTOS运行到自己的项目来。那系好安全带，我们进入第一章。

文章的内容是相关联的，层层递进的，如果零基础的同学可以先从第一章开始了解。

注意：
这个系列并不会对用到的函数进行介绍，想要了解函数的具体用法，可以先了解运行方式与运行原理之后，之后详细再具体看用法。想要比较详细地了解细节，自己看文档。链接就放在这里啦。

官方文档

一、RT-THREAD 内核快速入门（一）

本文的环境keil，用Keil 模拟器 STM32F103 ，例程可以直接从官方文档下载，也会用到这个例程的一些源码。
下载例程

一、线程重要概念

解释：

线程也可以说是任务，举个煮饭例子，做饭分为三步：拿米，洗米，煮饭。这三个可以是三个任务，也可以是三个线程。将煮饭这一大步分为三个动作去做(线程)去做，顺序执行。线程任务的载体，具有一些属性，我们做饭只是通过划分为三个线程的这种方式去做饭，可以直接在main中做，一个大的线程中做。

线程的作用：

从上面的例子知道，线程只是达成任务的一种方式。利用多线程编程，将任务划分，使得思维更清晰，开发更迅速。多线程具有他自己的优势，在某种情况下，能加快开发进度。相应的，调试起来也更难。

线程的五个重要状态:

初始，就绪，运行，挂起，关闭。

初始状态：刚创建线程，还未放入队列中就是初始状态

就绪状态：线程（任务）以及准备好了，等到某些条件，线程就进入运行状态。

挂起状态：线程运行需要的一些条件，如果没有这些条件，就进入挂起。

关闭状态：线程从队列中脱离/删除。

在这五个状态中，最核心的就是就绪和挂起，线程的状态只要在队列中，一般来说，不是就绪，运行就是挂起。我们控制线程的状态一般控制线程从就绪到挂起，控制的这个过程就通过线程间的通信或者同步。下面的一些函数就是控制线程的状态的，就绪与挂起的函数是最多的，核心就这两个家伙。

在这里插入图片描述

二、创建线程

创建线程先前，还需要大概了解启动流程（大概从哪里开始运行，我们的代码实际是在哪运行的）和自处初始化（调用函数的一种方式）

启动流程：

这里仅仅做简单讨论，讨论仅仅与main启动，常规裸机启动的一些区别。

裸机启动流程：启动文件 - >中间省略 - > main
rt-thread启动:启动文件 - >中间省略 - > rtthread_startup -> main

rt-thread启动和裸机启动的初略区别在，rtt启动是从这个函数rtthread_startup开始对内核进行初始化，最后到main线程，一般我们写函数初始化，比如线程创建是在main中的。

自初始化：

调用宏定义：

MSH_CMD_EXPORT(command, desc)

进行我们的函数初始化，传入函数的地址即可，与字符串（串口1命令）。调用这个宏是在main之前进行初始化，这样的隐性调用，不必想在写裸机那样进行直接调用，也能进行调用，我们在这里进行线程的创建。

线程重要属性：

优先级，时间片，栈大小，入口函数，线程结构体。

优先级：线程优先级，线程按照优先级进行执行，优先级等级越低优先级越高，0最高。如果有两个相同优先级的线程，就轮流执行。

时间片：每个线程执行的时间，仅仅在优先级相同的情况有用

栈大小：存放线程的局部变量以及函数入口和出口的内存区，这个在切换线程的时候，将原先执行的状态保存下来，直到下一个执行这个线程，读取线程的保存状态，比如局部变量等。这样就不会像执行函数那样，跳出函数就丢失了变量以及跳出时候执行的位置。

入口函数：线程实际执行的函数

入口函数参数：传递到入口函数的参数，通常是RT_NULL

线程结构体：内核通过线程结构体管理线程。

创建静态线程：

例程1：优先级相同线程

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

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


/* 线程1的入口函数 */
static void thread1_entry(void *parameter)
{
    rt_uint32_t count = 0;
		while(1)
		{
			count++;
			rt_kprintf("thread1 is ruing count is: %d\n", count);
			rt_thread_mdelay(300);
		}
}
//对齐方式
ALIGN(RT_ALIGN_SIZE)

static char thread1_stack[1024];
static struct rt_thread thread1;

static char thread2_stack[1024];
static struct rt_thread thread2;
/* 线程2入口 */
static void thread2_entry(void *param)
{
    rt_uint32_t count = 0;
		while(1)
		{
			count++;
			rt_kprintf("thread2 is ruing count is: %d\n", count);
			rt_thread_mdelay(300);//线程挂起，让出CPU持有权，知道300ms后，线程唤醒，参与调度
			if(count >5) break;
		}
    rt_kprintf("thread2 exit\n");
    /* 线程2运行结束后也将自动被系统删除
    (线程控制块和线程栈依然在idle线程中释放) */
}

/* 删除线程示例的初始化 */
int thread_sample(void)
{
    /* 初始化线程1，名称是thread1，入口是thread1_entry */
    rt_thread_init(&thread1,
                   "threa1",
                   thread1_entry,
                   RT_NULL,
                   &thread1_stack[0],
                   sizeof(thread1_stack),
                   THREAD_PRIORITY - 1, THREAD_TIMESLICE);
    rt_thread_startup(&thread1);
									 
    /* 初始化线程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);

运行结果：线程间轮流执行
在这里插入图片描述

例程2：优先级不同线程。

优先级高的先执行，优先级低的不能执行实验，线程无线程让出CPU

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

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


/* 线程1的入口函数 */
static void thread1_entry(void *parameter)
{
    rt_uint32_t count = 0;
		while(1)
		{
			count++;
			rt_kprintf("thread1 is ruing count is: %d\n", count);
			rt_thread_mdelay(300);
		}
}
//对齐方式
ALIGN(RT_ALIGN_SIZE)

static char thread1_stack[1024];
static struct rt_thread thread1;

static char thread2_stack[1024];
static struct rt_thread thread2;
/* 线程2入口 */
static void thread2_entry(void *param)
{
    rt_uint32_t count = 0;
		while(1)
		{
			count++;
			rt_kprintf("thread2 is ruing count is: %d\n", count);
			rt_thread_mdelay(300);
			if(count >5) break;
		}
    rt_kprintf("thread2 exit\n");
    /* 线程2运行结束后也将自动被系统删除
    (线程控制块和线程栈依然在idle线程中释放) */
}

/* 删除线程示例的初始化 */
int thread_sample(void)
{
    /* 初始化线程1，名称是thread1，入口是thread1_entry */
    rt_thread_init(&thread1,
                   "threa1",
                   thread1_entry,
                   RT_NULL,
                   &thread1_stack[0],
                   sizeof(thread1_stack),
                   THREAD_PRIORITY - 1, THREAD_TIMESLICE);
    rt_thread_startup(&thread1);
									 
    /* 初始化线程2，名称是thread2，入口是thread2_entry */
    rt_thread_init(&thread2,
                   "thread2",
                   thread2_entry,
                   RT_NULL,
                   &thread2_stack[0],
                   sizeof(thread2_stack),
                   THREAD_PRIORITY, THREAD_TIMESLICE);
    rt_thread_startup(&thread2);

    return 0;
}

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

运行结果：
在这里插入图片描述

例程三：栈溢出实验
常出现的错误

/*
 * 程序清单：栈溢出实验
 * 这个例子会创建两个线程,两个静态线程。
 * 一个线程在运行完毕后自动被系统删除，另一个线程一直打印计数。
 */
#include <rtthread.h>

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


/* 线程1的入口函数 */
static void thread1_entry(void *parameter)
{
    rt_uint32_t count = 0;
		while(1)
		{
			count++;
			rt_kprintf("thread1 is ruing count is: %d\n", count);
			rt_thread_mdelay(500);
		}
}
//对齐方式
ALIGN(RT_ALIGN_SIZE)

static char thread1_stack[1024];
static struct rt_thread thread1;

static char thread2_stack[50];
static struct rt_thread thread2;
/* 线程2入口 */
static void thread2_entry(void *param)
{
    rt_uint32_t count = 0;
		while(1)
		{
			count++;
			rt_kprintf("thread2 is ruing count is: %d\n", count);
			if(count >5) break;
		}
    rt_kprintf("thread2 exit\n");
    /* 线程2运行结束后也将自动被系统删除
    (线程控制块和线程栈依然在idle线程中释放) */
}

/* 删除线程示例的初始化 */
int thread_sample(void)
{
    /* 初始化线程1，名称是thread1，入口是thread1_entry */
    rt_thread_init(&thread1,
                   "threa1",
                   thread1_entry,
                   RT_NULL,
                   &thread1_stack[0],
                   sizeof(thread1_stack),
                   THREAD_PRIORITY - 1, THREAD_TIMESLICE);
    rt_thread_startup(&thread1);
									 
    /* 初始化线程2，名称是thread2，入口是thread2_entry */
    rt_thread_init(&thread2,
                   "thread2",
                   thread2_entry,
                   RT_NULL,
                   &thread2_stack[0],
                   sizeof(thread2_stack),
                   THREAD_PRIORITY, THREAD_TIMESLICE);
    rt_thread_startup(&thread2);

    return 0;
}

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