第三章节：深入浅出——RT_Thread线程创建与使用

最新推荐文章于 2025-03-26 16:54:01 发布
最新推荐文章于 2025-03-26 16:54:01 发布
阅读量3.2k 收藏 67
点赞数 55
分类专栏： RT_Thread 学习 文章标签： stm32 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77476804/article/details/143243365
版权

1. 线程基础概念回顾 

  • 线程与进程的区别

  1. 进程：是操作系统进行资源分配和调度的基本单位。它是一个具有独立功能的程序关于某个数据集合的一次运行活动，是系统进行资源分配和调度的一个独立单位。
  2. 线程：是进程的执行单元，是进程内一个相对独立的、可调度的执行流，是CPU调度和分派的基本单位。

  • 线程的组成：

  1. 在 RT-Thread 中，线程是 RT-Thread 中最基本的调度单位，使用 rt_thread 结构体表

    示线程。

    rt_thread 描述了一个线程执行的运行环境，也描述了这个线程所处的优先等级。

    系统中总共存在两类线程，分别是系统线程和用户线程

    系统线程由 RT-Thread 内核创建

    用户线程由用户应用程序创建

  2. 这两类线程都会从内核对象容器中分配线程对象，如下图所示。
    每个线程由三部分组成：线程控制块 (rt_thread 结构体 ) 、线程栈和入口函数

  • 线程的状态转换

  1. 线程运行的过程中，一个时间内只允许一个线程在处理器中运行，从运行的过程上划
    分，线程有多种不同的运行状态，如运行态，非运行态等。在RT-Thread实时操作系统中，
    线程包含五种状态，操作系统会自动根据它运行的情况而动态调整它的状态。 RT-Thread中
    的五种线程状态如下所示：

 

RT-Thread实时操作系统提供一系列的操作系统调用接口，使得线程的状态在这五个状
态之间来回的变换。例如一个就绪态的线程由于申请一个资源（例如使用rt_sem_take)，而
可能进入挂起态。又例如因为一个外部中断发生了，系统转入中断服务例程，在中断服务例
程中释放了相应的资源，导致把等待在这个资源上的高优先级线程唤醒，改变其状态为就绪
态，导致当前运行线程切换等等。
几种状态间的转换关系如 线程转换图 所示：

 

图 2.2: 线程转换图
线程通过调用函数rt_thread_create/init进入到初始状态（RT_THREAD_INIT）；再通
过调用函数rt_thread_startup进入到就绪状态（RT_THREAD_READY）；当处于就绪状态
的线程调用rt_thread_delay，rt_sem_take，rt_mb_recv等函数或由于获取不到资源时，
将进入到挂起状态（RT_THREAD_SUSPEND）；处于挂起状态的线程，如果等待超时依然
未能获得资源或由于其他线程释放了资源，那么它将返回到就绪状态。挂起状态的线
程，如果调用rt_thread_delete/detach将更改为关闭状态（RT_THREAD_CLOSE）；而运行
状态的线程，如果运行结束会在线程最后部分执行rt_thread_exit函数而更改为关闭状态
（RT_THREAD_CLOSE）

  • 线程调度

  1. RT-Thread中提供的线程调度器是基于优先级的全抢占式调度：在系统中除了中断处理
    函数、调度器上锁部分的代码和禁止中断的代码是不可抢占的之外，系统的其他部分都是可
    以抢占的，包括线程调度器自身。系统总共支持256个优先级(0 ～ 255，数值越小的优先级
    越高，0为最高优先级，255分配给空闲线程使用，一般用户不使用。在一些资源比较紧张
    的系统中，可以根据实际情况选择只支持8个或32个优先级的系统配置)。在系统中，当有比
    当前线程优先级更高的线程就绪时，当前线程将立刻被换出，高优先级线程抢占处理器运
    行。
    如图 线程就绪优先级队列 所示，在RT-Thread调度器的实现中,包含了一个共256个优先
    级队列的数组(如果系统最大支持32个优先级，那么这里将是一个包含了32个优先级队列的
    数组)，每个数组元素中放置相同优先级链表的表头。这些相同优先级的列表形成一个双向
    环形链表，最低优先级线程链表一般只包含一个idle线程。
在优先级队列1#和2#中，可以看到三个线程：线程A、线程B和线程C。由于线程A、B
的优先级比线程C的高，所以此时线程C得不到运行，必须要等待优先级队列1#的中所有线
程（因为阻塞）都让出处理器后才能得到执行。
一个操作系统如果只是具备了高优先级任务能够“立即”获得处理器并得到执行的特
点，那么它仍然不算是实时操作系统。因为这个查找最高优先级线程的过程决定了调度时间
是否具有确定性，例如一个包含n个就绪任务的系统中，如果仅仅从头找到尾，那么这个时
间将直接和n相关，而下一个就绪线程抉择时间的长短将会极大的影响系统的实时性。当所
有就绪线程都链接在它们对应的优先级队列中时，抉择过程就将演变为在优先级数组中寻找
具有最高优先级线程的非空链表。RT-Thread内核中采用了基于位图的优先级算法（时间复
杂度O(1)，即与就绪线程的多少无关），通过位图的定位快速的获得优先级最高的线程。
RT-Thread内核中也允许创建相同优先级的线程。相同优先级的线程采用时间片轮转方
式进行调度（也就是通常说的分时调度器），时间片轮转调度仅在当前系统中无更高优先级
就绪线程存在的情况下才有效。例如在 线程就绪优先级队列 图中，我们假设线程A和线程B
一次最大允许运行的时间片分别是10个时钟节拍和7个时钟节拍。那么线程B将在线程A的时
间片结束（10个时钟节拍）后才能运行，但如果中途线程A被挂起了，即线程A在运行的途
中，因为试图去持有不可用的资源，而导致线程状态从就绪状态更改为阻塞状态，那么线程
B会因为其优先级成为系统中就绪线程中最高的而马上运行。每个线程的时间片大小都可以
在初始化或创建这个线程时指定。
因为RT-Thread调度器的实现是采用优先级链表的方式，所以系统中的总线程数不受限
制，只和系统所能提供的内存资源相关。为了保证系统的实时性，系统尽最大可能地保证高
优先级的线程得以运行。线程调度的原则是一旦任务状态发生了改变，并且当前运行的线程
优先级小于优先级队列组中线程最高优先级时，立刻进行线程切换（除非当前系统处于中断
处理程序中或禁止线程切换的状态）。

2. 调度器相关接口

2.1.1 调度器初始化
在系统启动时需要执行调度器的初始化，以初始化系统调度器用到的一些全局变量。调
度器初始化可以调用下面的函数接口。

void rt_system_scheduler_init(void)

2.1.2 启动调度器
在系统完成初始化后切换到第一个线程，可以调用下面的函数接口。
void rt_system_scheduler_start(void);
在调用这个函数时，它会查找系统中优先级最高的就绪态线程，然后切换过去执行。另
外在调用这个函数前，必须先做idle线程的初始化，即保证系统至少能够找到一个就绪状态
的线程执行。此函数是永远不会返回的。
2.1.3 执行调度
让调度器执行一次线程的调度可通过下面的函数接口。
void rt_schedule(void);
调用这个函数后，系统会计算一次系统中就绪态的线程，如果存在比当前线程更高优先

级的线程时，系统将切换到高优先级的线程去。上层应用程序一般不需要调用这个函数。

2.1.4 设置调度器钩子
在整个系统的运行时，系统都处于线程运行、中断触发-响应中断、切换到其他线程，
甚至是线程间的切换过程中，或者说系统的上下文切换是系统中最普遍的事件。有时用户可
能会想知道在一个时刻发生了什么样的线程切换，可以通过调用下面的函数接口设置一个相
应的钩子函数。在系统线程切换时，这个钩子函数将被调用：
void rt_scheduler_sethook(void (*hook)(struct rt_thread* from, struct rt_thread* to));
这个函数用于把用户提供的hook函数设置到系统调度器钩子中，当系统进行上下文切
换时，这个hook函数将会被系统调用。
这个hook函数的声明如下：
void hook(struct rt_thread* from, struct rt_thread* to);
函数参数
参数:
描述
from
表示系统所要切换出的线程控制块指针；
to
表示系统所要切换到的线程控制块指针。
函数返回
无
• 注：请仔细编写你的钩子函数，稍有不慎将很可能导致整个系统运行不正常（在这个
钩子函数中，基本上不允许调用系统API，更不应该导致当前运行的上下文挂起）。

3. 线程的创建方法

3.1 1.线程控制块
线程控制块由结构体 struct rt_thread 表示，线程控制块是操作系统用于管理线程的一
个数据结构。
它存放线程的一些信息，例如优先级、线程名称、线程状态等，也包含线程与线程之
间连接用的链表结构，线程等待事件集合等。
它在 rtdef.h 中定义如下 
/**
* Thread structure
*/
struct rt_thread
{
   /* rt 对象 */
     char name[RT_NAME_MAX]; /* 线程名字 */
     rt_uint8_t type; /* 对象类型 */
     rt_uint8_t flags; /* 标注位 */
     rt_list_t list; /* 对象列表 */
     rt_list_t tlist; /* 线程列表 */
 /* 栈指针和入口指针 */
     void *sp; /* 栈指针 */
     void *entry; /* 入口函数指针*/
     void *parameter; /* 参数 */
     void *stack_addr; /* 栈地址指针 */
     rt_uint32_t stack_size; /* 栈大小*/
 /* 错误代码 */
     rt_err_t error; /* 线程错误代码 */
     rt_uint8_t stat; /* 线程状态 */
 /* 优先级 */
     rt_uint8_t current_priority; /* 当前优先级 */
     rt_uint8_t init_priority; /* 初始优先级 */
…………
     rt_ubase_t init_tick; /* 线程初始化计数值 */
     rt_ubase_t remaining_tick; /* 线程剩余计数值 */
     struct rt_timer thread_timer; /* 内置线程定时器 */
     void (*cleanup)(struct rt_thread *tid); /* 线程退出清理函数 */
     rt_uint32_t user_data; /* 用户私有数据*/
};
    typedef struct rt_thread *rt_thread_t;
3.1.2.线程栈
在裸机系统中， 涉及局部变量、子函数调用或中断发生，就需要用到栈。
在 RTOS 系统中，每个线程运行时，也是普通的函数调用，也涉及局部变量、子函数
调用、中断，也要用到栈。
但不同于裸机系统， RTOS 存在多个线程，每个线程是独立互不干扰的，因此需要为
每个线程都分配独立的栈空间，这就是线程栈。
可以使用两种方法提供线程栈：静态分配、动态分配。栈的大小通常由用户定义，如
下使用全局数组提供了一个静态栈，大小为 512 字节：
rt_uint32_t test_stack[512];
3.1.3入口函数
入口函数是线程要运行函数，由用户自行设计。
可分为无限循环模式和顺序执行模式。
无限循环模式： 
void thread_entry(void* paramenter)
{
 while (1)
 {
 /* 等待事件的发生 */
 /* 对事件进行服务、进行处理 */
 }
}
顺序执行模式： 
static void thread_entry(void* parameter)
{
 /* 处理事务 #1 */
 …
 /* 处理事务 #2 */
 …
 /* 处理事务 #3 */
}
使用这种模式时，线程不会一直循环，最后一定会执行完毕。
执行完毕后，线程将被系统自动删除。

4. 线程的使用及创建

4.1 线程的创建与启动
RT-Thread 提供两种线程的创建方式：
静态线程：使用 rt_thread_init() 初始化
动态线程：使用 rt_thread_create() 创建
区别：动态线程是系统自动从动态内存堆上分配栈空间与线程句柄，静态线程是由用
户分配栈空间与线程句柄
静态线程初始化函数如下 
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 );
 4.2  线程的删除
创建线程时有 2 种方式，删除线程时也有对应的函数： 
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_delete 并不是真正的删除线程，只是把线程状态状态改为 RT_THREAD_CLOSE。
  • 真正的删除(释放线程控制块和线程栈)，在下一次执行空闲线程时，由空 闲线程删除
  • 线程本身不应调用 rt_thread_detach 脱离线程

5. 实际案例分析与代码演示

示例 1: 创建线程
代码为： RT-Thread_01_create_task
使用两种方式分别创建两个线程。
线程 1 的代码： 
/* 线程 1 的入口函数 */
static void thread1_entry(void *parameter)
{
const char *thread_name = "Thread1 run\r\n";
volatile rt_uint32_t cnt = 0;
/* 线程 1 */
while(1)
{
/* 打印线程 1 的信息 */
rt_kprintf(thread_name);
/* 延迟一会(比较简单粗暴) */
for( cnt = 0; cnt < 100000; cnt++ )
{
}
}
}
线程 2 的代码： 
/* 线程 2 入口函数 */
static void thread2_entry(void *param)
{
const char *thread_name = "Thread2 run\r\n";
volatile rt_uint32_t cnt = 0;
/* 线程 2 */
while(1)
{
/* 打印线程 2 的信息 */
rt_kprintf(thread_name);
/* 延迟一会(比较简单粗暴) */
for( cnt = 0; cnt < 100000; cnt++ )
{
}
}
}
main 函数： 
int main(void)
{
/* 初始化静态线程 1，名称是 Thread1，入口是 thread1_entry */
 rt_thread_init(&thread1, //线程句柄
 "thread1", //线程名字
 thread1_entry, //入口函数
 RT_NULL, //入口函数参数
 &thread1_stack[0], //线程栈起始地址
 sizeof(thread1_stack), //栈大小
 THREAD_PRIORITY, //线程优先级
 THREAD_TIMESLICE); //线程时间片大小 
/* 启动线程 1 */
 rt_thread_startup(&thread1); 
/* 创建动态线程 2，名称是 thread2，入口是 thread2_entry*/
 thread2 = rt_thread_create("thread2", //线程名字
 thread2_entry, //入口函数
RT_NULL, //入口函数参数
 THREAD_STACK_SIZE, //栈大小
 THREAD_PRIORITY, //线程优先级
 THREAD_TIMESLICE); //线程时间片大小
 /* 判断创建结果,再启动线程 2 */
 if (thread2 != RT_NULL)
 rt_thread_startup(thread2); 
 
 return 0;
}

注意：
  • 线程 1 是静态初始化，线程 2 是动态初始化
  • 它们的优先级，时间片大小都设置一样
线程运行图：
  • thread1 和 thread2 优先级相同，因此不存在抢占
  • 在 t1，thread1 进入运行态，一直运行直到 t2；这个时间长度就是 thread1
  • 设置的时间片长度，15 个 Tick 时钟节拍
  • 在 t2，thread2 进入运行态，一直运行直到 t3；这个时间长度就是 thread2
  • 设置的时间片长度，15 个 Tick 时钟节拍
  • 在 t3，thread1 重新进入运行态，如此交替

 

 示例 2: 使用线程参数
代码为： RT-Thread_02_create_task_use_params
多个线程可以使用同一个函数，怎么体现它们的差别？
栈不同
创建线程时可以传入不同的参数
我们创建 2 个线程，使用同一个函数，代码如下： 
/* 线程的入口函数 */
static void thread1_entry(void *parameter)
{
const char *thread_name = parameter;
volatile rt_uint32_t cnt = 0;
/* 线程 */
while(1)
{
/* 打印线程的信息 */
rt_kprintf(thread_name);
/* 延迟一会(比较简单粗暴) */
for( cnt = 0; cnt < 100000; cnt++ )
{
}
}
}
上述代码中的 thread_name 来自参数 parameter ， parameter 来自哪里？创建线程时
传入的。
代码如下：
使用 rt_thread_init 和 rt_thread_create 分别创建线程时，传入不同的函数
参数
不同的线程， parameter 不一样 
static const char *thread1_name = "Thread1 run\r\n";
static const char *thread2_name = "Thread2 run\r\n";
int main(void)
{
/* 初始化静态线程 1，名称是 Thread1，入口是 thread1_entry */
 rt_thread_init(&thread1, //线程句柄
 "thread1", //线程名字
 thread1_entry, //入口函数
 (void *)thread1_name, //入口函数参数
 &thread1_stack[0], //线程栈起始地址
 sizeof(thread1_stack), //栈大小
 THREAD_PRIORITY, //线程优先级
 THREAD_TIMESLICE); //线程时间片大小 
/* 启动线程 1 */
 rt_thread_startup(&thread1); 
/* 创建动态线程 2，名称是 thread2，入口也是 thread1_entry*/
 thread2 = rt_thread_create("thread2", //线程名字
 thread1_entry, //入口函数
(void *)thread2_name, //入口函数
参数
 THREAD_STACK_SIZE, //栈大小
 THREAD_PRIORITY, //线程优先级
 THREAD_TIMESLICE); //线程时间片大小
 /* 判断创建结果,再启动线程 2 */
 if (thread2 != RT_NULL)
 rt_thread_startup(thread2); 
 
 return 0;
}

5. 本章小结

  • 掌握线程创建与使用的是关键点。
  • 了解不同创建方法的适用场景 如静态创建及动态创建的区别及在内核中如何分布的（详细价将会在后面慢慢补充）。
  • 下一章节将详细讲解线程优先级和tick及空闲线程。

结语

在结束本章的学习后，我想对读者说：

  • 请务必动手实践本章所学的知识，只有通过实际编码，才能真正理解和掌握线程的创建与使用。
  • 在实践中不断探索，尝试解决实际问题，这将帮助你更好地理解并发编程的复杂性和挑战。

深度强化学习算法实践
AI天才研究院
10-12 550
深度强化学习（Deep Reinforcement Learning）是深度神经网络与强化学习相结合的方法，可以用于复杂的控制任务，能够在不访问环境模型的情况下学习到智能体对环境行为的最优策略，促进智能体的长期稳定增益。近年来深度强化学习方法已经得到了广泛的应用，并取得了良好的效果。本文将对深度强化学习的主要概念、方法及其相关技术进行深入浅出的剖析，从理论出发逐步探讨如何实现并训练深度强化学习算法。
[rt-thread]一、创建线程
peng19106的博客
06-13 417
学会如何通过rt-thread去创建一个线程，并通过自动初始化机制，将创建线程模块化，方便之后的工作学习！！！
RT-Thread(RTT)如何查看线程栈的使用情况以及确定线程栈的大小
qq_52251819的博客
12-18 3716
前言 创建线程时，需要确定线程栈空间，栈设置过大会浪费空间导致其它线程不够用。栈设置过小会导致栈溢出，会发生不可预测的错误 一、查看线程栈 1、线程写好后，连接好串口，打开串行终端 2、确定你连接的串口的端口，以及串口波特率 3、在终端按回车弹出msh >后，输入list_thread，再按回车，就会显示目前所创建的线程，以及线程优先级、线程栈大小、线程栈使用情况等信息 4、线程的名称 5、线程的优先级 6、线程的状态 7、线程的栈大小，使用的是十六进制表示 8、线程栈的利用率 二
RT-Thread：开源的实时操作系统全解析
最新发布
weixin_44727517的博客
03-26 1355
RT-Thread是一个嵌入式实时多线程操作系统实时性：支持硬实时（μs级响应）和软实时需求组件化架构：最小内核仅3KB ROM占用（Nano版本）跨平台支持：覆盖ARM Cortex-M/R/A、RISC-V、Xtensa等主流架构丰富生态：内置文件系统、网络协议栈、GUI框架等组件。
RT-Thread线程-创建线程
weixin_42530814的博客
04-25 1587
它是线程在系统中的核心表示，存储了线程的关键属性、状态信息以及与线程生命周期管理相关的数据。：TCB存储了线程执行时的CPU寄存器状态（如程序计数器PC、通用寄存器、状态寄存器等），当发生线程上下文切换时，这些信息会被保存到当前线程的TCB中，同时从即将运行的线程TCB中加载相应的寄存器状态，从而实现线程执行现场的切换。：TCB作为线程的唯一标识，记录线程的唯一标识符（线程ID）和当前状态（如就绪、运行、挂起、阻塞、结束等），使得操作系统能够准确跟踪和控制各个线程的执行情况。
创建rt_thread线程
RONG_YAO的博客
06-18 2125
目录系列文章目录一、SRAM静态内存1、定义线程函数2、创建线程栈3.主函数二、SRAM 动态内存1、动态内存来源2、动态创建线程总结第一章:将rt_thread移植到stm32第二章:创建rt_thread线程前言本章学习如何使用rt_thread创建线程 2、创建线程栈 线程的栈是一个全局数组。 线程的栈占用的是 MCU 内部的 RAM，当线程越多的时候，需要使用的 栈空间就越大，即需要使用的 RAM 空间就越多。 MCU支持多少个线程取决于RAM的大小。 3.主函数
RTThread创建线程.rar
04-29
基于博客中Rt-Thread学习笔记-----线程创建（三）的测试工程。里面包含RTThread的单线程动态、静态创建，以及多线程动态静态的配合（基于Stm32F103Zet6、Keil5、rtthread3.1.3）
RT-Thread-02-线程创建
u012084226的博客
06-23 413
RTT中没个线程都具有独立的栈空间，在进行线程切换时，系统会将当前线程的上下文保存在线程中，当线程要恢复运行时，再从线程栈读取上下文信息，恢复线程的运行；线程上下文是指线程执行的环境，具体来说就是各个变量和数据包括所有寄存器变量、堆栈信息、内存信息等；线程栈在形式上是一段连续的内存空间，可以通过定义一个数组或者申请一段动态内存来作为线程的栈。
RTthread-线程的创建
weixin_52694360的博客
05-12 4512
RT-Thread名为实时线程RTOS， 那么什么叫线程? 人们在生活中处理复杂问题时，惯用的方法就是“分而治之”，即把一个大问题分解成多个相对简单、比较容易解决的小问题，小问题逐个被解决了，大问题也就随之解决了。同样，在设计一个较为复杂的应用程序时，也通常把一个大型任务分解成多个小任务，然后通过运行这些小任务，最终达到完成大任务的目的。 在RT-Thread中，与上述小任务对应的程序实体就叫做“线程”(或任务)，RT-Thread就是一个能对这些小“线程”进行管理和调度的多“线程”操作系统。 线程是实现任
深入浅出DPDK学习笔记（5）——— 同步互斥机制
superbfly的专栏
10-22 2222
同步互斥机制原子操作处理器上的原子操作Linux内核原子操作原子整数操作原子性与顺序性原子位操作DPDK原子操作实现和应用内存屏障API原子操作API读写锁Linux读写锁主要APIDPDK读写锁实现和应用自旋锁自旋锁的缺点Linux自旋锁APIDPDK自旋锁实现和应用无锁机制Linux内核无锁环形缓冲DPDK无锁环形缓冲rte_ring的数据结构定义环形缓冲区的剖析单生产者入队单消费者出队多生产者入队小结 DPDK根据多核处理器的特点,遵循资源局部化的原则,解耦数据的跨核共享,使得性能可以有很好的水平扩展
深入理解JVM——第五章、JVM性能优化学习笔记
hankin的博客
06-06 1802
一、内存溢出 内存溢出的原因：程序在申请内存时，没有足够的内存空间 1、栈溢出 方法死循环递归调用（StackOverflowError）、不断建立线程（OutOfMemoryError） 由于在Hotspot虚拟机中并不区分虚拟机栈和本地方法栈，因此，对于Hotspot来说，虽然-Xoss参数（设置本地方法栈大小）存在，但实际上是无效的，栈容量只由-Xss参数设定，关于虚拟机栈和本地...
Linux中的线程
zsffzb的博客
11-04 1856
1.线程的基本概念 2.线程和进程的区别 *线程的同步 线程的调度 线程的通信编程思想之多线程与多进程(1)——以操作系统的角度述说线程与进程_阳光日志-CSDN博客_多线程和多进程编程线程是什么？要理解这个概念，须要先了解一下操作系统的一些相关概念。大部分操作系统(如Windows、Linux)的任务调度是采用时间片轮转的抢占式调度方式，也就是说一个任务执行一小段时间后强制暂停去执行下一个任务，每个任务轮流执行。任务执行的一小段时间叫做时间片，任务正在执行时的状态叫运行状态，任务执行一段时间后强制
RT-Thread 入门学习例程静态动态线程的创建，第一节的程序
08-24
RT-Thread 入门学习例程静态动态线程的创建，第一节的程序
深入理解Java虚拟机（全）
qq_45424937的博客
08-08 1787
​ ​ 垃圾回收，类加载，线程安全问的比较多 2，3，6，7，12，13 第二章 Java内存区域与内存溢出异常 2.2 运行时数据区域 3个区域线程私有（不需要垃圾回收，因为它们随着线程结束而自动销毁），2个区域所有线程共享（需要垃圾收集回收） 程序计数器（Programmer Counter Register）：一块很小的内存，可以看做当前线程所执行的字节码的行号计数器。 线程隔离的数据区（线程私有） 为了多线程切换后能恢复到正确的执行位置，每条线程都需要一个独立的程序计数器，各线程之间计数
RT-Thread-线程的创建
weixin_45596239的博客
03-16 437
第三章 线程的创建 一 什么是线程？ 基本概念 线程是实现任务的载体，它是RT-Thread中最基本的调度单位，它描述了一个 任务执行的运行环境，也描述了这个任务所处的优先等级。 二 线程组成 RT-Thread中，线程由三部分组成：线程代码(入口函数)、线程控制块、线程堆栈 三 线程创建 1、创建进程 （1）创建静态线程 rt_err_t rt_thread_init(struct rt_thread *thread, ...
RT-Thread创建线程函数
qq_63376551的博客
11-28 299
构造好这个一个栈，然后将rt-thread 的sp指针 r4 栈尾。之后运行 这个线程时 将创建的栈中的词 写入CPU寄存器中。ro为参数寄存器 在函数入口时 将参数传置R0寄存器之中。该值 保存在栈中 之后再赋值给PC寄存器。1.分配了一个RT_thread 结构体。存在栈中的 有R0到R15 ，PSR。R13不保存 其别名为栈 保存在sp。PSR: 函数运行过程中断的开还是关。
【RT-Thread基础教程】线程的基本使用
m0_62599305的博客
02-23 4173
在嵌入式系统开发中，RTOS（Real-Time Operating System）扮演着至关重要的角色，而RT-Thread作为一款开源的实时操作系统，在嵌入式领域中备受欢迎。线程是RTOS中的基本执行单元，其良好的多任务处理能力使得嵌入式系统能够更有效地响应各种事件和任务。本文将着重介绍在RT-Thread中线程的基本使用方法，包括线程的创建、调度、挂起和删除等方面。通过深入理解线程的基本概念和操作，读者将能更好地利用RT-Thread构建稳定而高效的嵌入式系统。
RT-Thread: 线程创建及应用
yutian0606的博客
01-10 980
这里记录 RT-Thread 的具体创建过程，相当于线程创建的一个模式，具体线程相关的信息没做介绍， RT-Thread 的官方文档里面已经有详细介绍，如有需要请移步官网。
RT-thread创建线程并且启动
weixin_44678052的博客
07-08 881
创建线程有两种方式，根据是否由rt分配内存，分为静态创建线程和动态创建线程。默认是静态分配线程，如果需要使用动态创建线程的话，则需要开启宏定义RT_USING_HEAP，并设置heap相关函数。 thread ： 线程句柄 name ：线程名字 parameter ：线程入口函数 stack_start: 线程栈起始地址 stack_size : 线程栈的大小 priority: 线程的优先级 tick: 线程的时间片大小 三. 动态创建线程 调用这个函数，会返回线程句柄。 在使用这个函数的时候，需要
rtthread创建线程时给线程传递参数
01-22
### RT-Thread 中创建线程并传递参数 在 RT-Thread 操作系统中，可以通过 `rt_thread_create` 函数来创建一个新的线程，并可以向该线程传递参数。下面具体介绍这一过程。 #### 创建线程函数原型 创建新线程使用的 API 是 `rt_thread_t rt_thread_create(const char* name, void (*thread_entry)(void *parameter), void *parameter, int stack_size, int priority, int tick)`[^1]。此接口允许指定线程名称、入口函数及其参数、栈大小、优先级以及时间片长度。 #### 参数解释 - **name**: 线程的名字，便于调试和识别。 - **thread_entry**: 新线程执行的起始地址，即线程主体函数指针。 - **parameter**: 向线程传递的数据，作为启动时传给线程主体函数的唯一参数。 - **stack_size**: 设置分配给线程堆栈的空间大小（单位字节），应根据实际需求合理设置。 - **priority**: 定义线程运行优先级，数值越低表示优先级别越高。 - **tick**: 时间片数量，决定了调度器多久切换一次当前正在运行的任务到其他等待处理的任务上。 #### 示例代码展示 以下是使用 C 语言编写的简单例子，展示了如何创建带有参数的新线程： ```c #include "rtthread.h" // 定义要在线程内调用的工作函数 static void thread_entry(void *param) { while (1) { // 打印接收到的消息 rt_kprintf("Received parameter: %s\n", (char *)param); // 延迟一段时间再继续循环 rt_thread_mdelay(1000); } } int main(void) { const char message[] = "Hello from new thread!"; // 使用 rt_thread_create 来实例化新的线程对象 struct rt_thread *new_thread; new_thread = rt_thread_create( "mythread", thread_entry, (void*)message, 1024, 10, 20); if(new_thread != RT_NULL){ // 如果成功创建，则启动这个线程 rt_thread_startup(new_thread); } return 0; } ``` 在这个例子中，通过 `main()` 函数内的 `rt_thread_create` 调用来建立名为 `"mythread"` 的新线程，并把字符串 `"Hello from new thread!"` 当作参数传递给了它。每当新线程被激活时就会打印这条消息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值