RT-Thread学习笔记（四）

线程间同步

线程间同步的作用：多个执行单元（线程、中断）同时执行临界区，操作临界资源，会导致竟态产生，线程间同步确保多个线程在访问共享资源时，能够按照正确的顺序执行，避免数据冲突和逻辑错误。

临界区（Critical Section）是指一个程序中访问共享资源（如全局变量、内存、文件、硬件设备）的一段代码区域，在这段代码执行过程中，必须保证同一时刻最多只能有一个线程进入执行，以避免数据竞争和不一致问题。

✅ 具体作用如下：
防止数据竞争（竞态条件）
多个线程同时修改同一份数据时，如果没有同步机制，就可能出现数据错误或程序行为异常。
保证数据一致性
同步机制（如互斥锁、信号量等）可以确保同一时间只有一个线程访问临界资源，保证操作的原子性。
协调线程执行顺序
某些任务必须在另一个线程完成之后才能执行，比如：先读取文件，后处理数据。这种依赖关系就需要同步手段来控制执行顺序。
提高程序稳定性与可靠性
通过同步机制可以避免死锁、资源冲突等常见问题，使并发程序更健壮。

🔧RT-Thread OS提供了如下几种同步互斥机制：
互斥锁（mutex）
信号量（semaphore）
事件集（event）

信号量

信号量是一种轻型的用于解决线程间同步问题的内核对象，即信号量也是通过结构体定义描述的，线程可以获取或释放它，从而达到同步或互斥的目的。每个信号量对象都有一个信号量值和一个线程等待队列，信号量的值对应了信号量对象的实例数目、资源数目，假如信号量值为 5，则表示共有 5 个信号量实例（资源）可以被使用，当信号量实例数目为零时，再申请该信号量的线程就会被挂起在该信号量的等待队列上，等待可用的信号量实例（资源）

例如初始化信号量值为 1 ，当线程执行到临界区时要获取信号量，此时信号量值为 1，因此该线程可以获取到信号量，当信号量被获取一次后，信号量值会 减1，此时信号量值为0，当下一个线程需要获取信号量时，该线程就会被挂起，放到一个等待队列中去，等到信号量资源大于0时，回到对应的等待队列把挂起的线程唤醒，即将线程从挂起态切换为就绪态

信号量结构体
该结构体里有信号量的value值，还有一个预留参数，为后期的扩展使用

struct rt_semaphore
{struct rt_ipc_object parent;                        /**< inherit from ipc_object */rt_uint16_t          value;                         /**< value of semaphore. */rt_uint16_t          reserved;                      /**< reserved field 预留*/
};
typedef struct rt_semaphore *rt_sem_t;

信号量的使用和管理

对一个信号量的操作包含：创建 / 初始化信号量、获取信号量、释放信号量、删除 / 脱离信号量

首先要创建或初始化一个信号量，线程在临界区前获取信号量，在临界区后释放信号量

动态创建信号量

动态创建信号量函数

第一个参数是信号量的名字，第二个是信号量值，

rt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag)#define RT_IPC_FLAG_FIFO                0x00            /**< FIFOed IPC. @ref IPC. */
#define RT_IPC_FLAG_PRIO                0x01            /**< PRIOed IPC. @ref IPC. */

✅ 1. RT_IPC_FLAG_FIFO（先进先出）
含义：按线程进入等待队列的先后顺序来唤醒（排队公平）。
特点：谁先来谁先走，无视线程优先级。
应用场景：对响应时间要求不高，强调公平性，例如：简单同步、非实时任务。
🧠 示例： 线程 A、B、C 优先级不同，但如果是 A 先等待信号量，那释放信号量时 A 会先被唤醒，即使 B 优先级更高。

✅ 2. RT_IPC_FLAG_PRIO（优先级优先）
含义：按线程的优先级高低来决定唤醒顺序。
特点：优先级高的线程先被唤醒。
应用场景：对实时性要求高的系统，优先响应高优先级任务。
🧠 示例： 线程 A（低优先级）先等待资源，线程 B（高优先级）后加入等待队列；当资源释放时，线程 B 会被优先唤醒。

系统不再使用信号量时，可通过删除信号量以释放系统资源，适用于动态创建的信号量。调用这个函数时，系统将删除这个信号量。如果删除该信号量时，有线程正在等待该信号量，那么删除操作会先唤醒等待在该信号量上的线程（等待线程的返回值是-RT_ERROR），然后再释放信号量的内存资源。

删除信号量函数

rt_err_t rt_sem_delete(rt_sem_t sem)

创建演示

#include <rtthread.h>#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>
#include "errno.h"rt_sem_t sem1;int main(void)
{sem1 = rt_sem_create("sem1_demo", 1, RT_IPC_FLAG_FIFO);//先进先出if(sem1 == RT_NULL)//如果创建失败{LOG_E("rt_sem_create failed...\n");return -ENOMEM;}LOG_D("rt_sem_create successed...\n");//如果创建成功return RT_EOK;
}

信号量创建成功，但是信号量的名字不是sem1_demo，少了一个字符，因为信号量名字最多8个字符

改短一点就可以了

静态创建信号量

初始化信号量

第一个参数是rt_sem_t 类型的结构体指针，需要定义，第二个参数是信号量的名字，第三个参数是信号量值，第四个参数是flag，与动态创建一样

rt_err_t rt_sem_init(rt_sem_t    sem,const char *name,rt_uint32_t value,rt_uint8_t  flag)

信号量脱离

脱离信号量就是让信号量对象从内核对象管理器中脱离，适用于静态初始化的信号量使用该函数后，内核先唤醒所有挂在该信号量等待队列上的线程，然后将该信号量从内核对象管理器中脱离。原来挂起在信号量上的等待线程将获得 - RT_ERROR 的返回值。

rt_err_t rt_sem_detach(rt_sem_t sem)

初始化演示

#include <rtthread.h>#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>
#include "errno.h"rt_sem_t sem1;struct rt_semaphore sem2;//定义一个信号量结构体用于初始化信号量int main(void)
{int ret = 0;//用于接收初始化的返回值sem1 = rt_sem_create("sem1", 1, RT_IPC_FLAG_FIFO);//先进先出if(sem1 == RT_NULL)//如果创建失败{LOG_E("rt_sem_create failed...\n");return -ENOMEM;}LOG_D("rt_sem_create successed...\n");//如果创建成功ret = rt_sem_init(&sem2, "sem2", 5, RT_IPC_FLAG_FIFO);if(ret < 0)//如果初始化失败{LOG_E("rt_sem_init failed...\n");return ret;}LOG_D("rt_sem_init successed...\n");//如果初始化成功return RT_EOK;
}

获取信号量

假设有一个临界资源是让 i++，如果两个线程都可以操作该临界资源，即两个线程都会让 i++，这时候就会发生竞争，因此就需要使用信号量的获取和释放

获取信号量函数

第一个参数是要获取哪个信号量，第二个参数timeout决定了是否阻塞等待，RT_WAITING_FOREVER表示一直等待，直到有信号量，T_WAITING_NO表示不等待，直接返回

rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t timeout)#define RT_WAITING_FOREVER              -1              /**< Block forever until get resource. */
#define RT_WAITING_NO                   0               /**< Non-block. */

另一个获取信号量的函数，等价于rt_sem_take(rt_sem_t sem, T_WAITING_NO)，即不等待，直接返回

rt_err_t rt_sem_trytake(rt_sem_t sem)

释放信号量函数

在操作完临界资源后要去释放信号量，不然其他线程无法获取这个信号量

rt_err_t rt_sem_trytake(rt_sem_t sem)

信号量同步实列

信号量的同步是指通过信号量（semaphore）来协调多个线程或任务之间的执行时机，使它们按照正确的顺序运行，从而实现“谁先做、谁后做”的同步控制关系。

#include <rtthread.h>#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>
#include "errno.h"rt_sem_t sem1;rt_thread_t th1,th2;int flag = 0;struct rt_semaphore sem2;//定义一个信号量结构体用于初始化信号量void th1_entry(void *parameter)//线程1入口函数
{while(1)//循环执行{rt_thread_mdelay(5000);//一开始处于阻塞状态，会跳转到线程2rt_sem_take(sem1, RT_WAITING_FOREVER );flag ++;if(flag == 100)flag = 0;rt_kprintf("th1_entry[%d]\n",flag);rt_sem_release(&sem2);}
}void th2_entry(void *parameter)//线程2入口函数
{while(1)//一开始跳转到线程2不会立即执行线程2，因为信号量2的值为0，因此处于挂起状态{rt_sem_take(&sem2, RT_WAITING_FOREVER);if(flag > 0)flag --;rt_kprintf("th2_entry[%d]\n",flag);rt_sem_release(sem1);rt_thread_mdelay(1000);}
}int main(void)
{int ret = 0;//用于接收初始化的返回值sem1 = rt_sem_create("sem1", 1, RT_IPC_FLAG_FIFO);//初始化信号量1的值为1if(sem1 == RT_NULL)//如果创建失败{LOG_E("rt_sem_create failed...\n");return -ENOMEM;}LOG_D("rt_sem_create successed...\n");//如果创建成功ret = rt_sem_init(&sem2, "sem2", 0, RT_IPC_FLAG_FIFO);//初始化信号量2的值为0if(ret < 0)//如果初始化失败{LOG_E("rt_sem_init failed...\n");return ret;}LOG_D("rt_sem_init successed...\n");//如果初始化成功th1 = rt_thread_create("th1", th1_entry, NULL, 512, 20, 5);if(th1 == RT_NULL){LOG_E("th1 rt_thread_create failed...\n");return -ENOMEM;}LOG_D("th1 rt_thread_create successed...\n");th2 = rt_thread_create("th2", th2_entry, NULL, 512, 20, 5);if(th2 == RT_NULL){LOG_E("th2 rt_thread_create failed...\n");return -ENOMEM;}LOG_D("th2 rt_thread_create successed...\n");rt_thread_startup(th1);rt_thread_startup(th2);return RT_EOK;
}

分别创建两个线程，flag作为临界区，两个线程都会对flag进行操作，因此需要通过信号量防止竞态的发生，在初始化时，信号量1的值为1，信号量2的值为2，线程th1获取的是信号量1，释放的是信号量2，线程2获取的是信号量2，释放的是信号量1

在一开始，线程1的入口函数先用一个延时阻塞，这时线程1被挂起，线程2被调度，但是此时的信号量2值为0，线程2获取不到信号量，因此线程2被挂起，等到线程1的延时结束，又回到线程1，此时线程1获取信号量1成功，执行相应的操作，然后释放信号量2，信号量1的值从1变为0，信号量2的值从0变为1，线程1执行完，又轮到线程2执行，此时信号量2值为1，因此线程2能够获取信号量2，对应的操作能够执行，线程2又释放信号量1，此时信号量1的值又变为1，信号量2的值又变为0，依次循环，就实现了信号的同步操作

互斥量

互斥量体现的是排他性，也是解决多线程同时操作临界区临界资源导致的竟态的一种方法。（类似于特殊的信号量——二值信号量（只有 0 和 1 ）），即一个线程在执行时，另一个线程不能执行，不强调顺序

与信号量的区别：信号量可由不同线程释放，互斥量只能由同一线程进行释放。

互斥量的使用和管理

互斥量的操作包含：创建 / 初始化互斥量、获取互斥量、释放互斥量、删除 / 脱离互斥量

互斥量动态创建

不再使用互斥量时，通过删除互斥量以释放系统资源，适用于动态创建的互斥量当删除一个互斥量时，所有等待此互斥量的线程都将被唤醒，等待线程获得的返回值是 - RT_ERROR

互斥量动态创建函数

rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag)#define RT_IPC_FLAG_FIFO                0x00            /**< FIFOed IPC. @ref IPC. */
#define RT_IPC_FLAG_PRIO                0x01            /**< PRIOed IPC. @ref IPC. */

互斥量删除函数

rt_err_t rt_mutex_delete(rt_mutex_t mutex)

#include <rtthread.h>#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>
#include "errno.h"rt_mutex_t mutex1;int main(void)
{mutex1 = rt_mutex_create("mutex1", RT_IPC_FLAG_FIFO);if(mutex1 == RT_NULL){LOG_E("mutex1 rt_mutex_create failed...\n");return -ENOMEM;}LOG_D("mutex1 rt_mutex_create successed...\n");return RT_EOK;
}

互斥量静态创建

使用该函数接口后，内核先唤醒所有挂在该互斥量上的线程（线程的返回值是 -RT_ERROR ） ，然后系统将该互斥量从内核对象管理器中脱离。

互斥量静态创建函数

第一个参数也是要先定义一个结构体作为参数传入

rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag)

互斥量脱离函数

rt_err_t rt_mutex_detach(rt_mutex_t mutex)

#include <rtthread.h>#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>
#include "errno.h"rt_mutex_t mutex1;struct rt_mutex mutex2;//定义一个结构体用于静态创建互斥量传参int main(void)
{int ret;//用于接收静态创建的返回值//动态创建mutex1 = rt_mutex_create("mutex1", RT_IPC_FLAG_FIFO);if(mutex1 == RT_NULL){LOG_E("mutex1 rt_mutex_create failed...\n");return -ENOMEM;}LOG_D("mutex1 rt_mutex_create successed...\n");//静态创建ret = rt_mutex_init(&mutex2, "mutex2", RT_IPC_FLAG_FIFO);if(ret < 0){LOG_E("mutex2 rt_mutex_init failed...\n");return ret;}LOG_D("mutex2 rt_mutex_init successed...\n");return RT_EOK;
}

互斥量获取和释放

互斥量获取函数

rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t timeout)#define RT_WAITING_FOREVER              -1              /**< Block forever until get resource. */
#define RT_WAITING_NO                   0               /**< Non-block. */

另一种获取函数，等价于rt_mutex_take(rt_mutex_t mutex,RT_WAITING_NO)

rt_err_t rt_mutex_trytake(rt_mutex_t mutex)

互斥量释放函数

rt_err_t rt_mutex_release(rt_mutex_t mutex)

获取相当于上锁，释放相当于解锁，上了锁的要等到解锁后才能使用，例如上厕所，有一个人进去了，上了锁，下一个人要使用这个厕所的话一定要等到上一个人解锁出来了，下一个人才能进入厕所，上锁，且没有顺序，谁先来就谁去

上面的内容都是创建或初始化，没有调用过删除或这脱离，在这里调用一下，看看效果是怎么样的，但是一般情况下一个线程或者信号量或互斥量创建之后，就会一直使用，因此不需要去删除，但有时也会存在特殊情况

互斥量实例

没有互斥量

#include <rtthread.h>#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>
#include "errno.h"rt_mutex_t mutex1;rt_thread_t th1,th2;int flag1 ,flag2;void th1_entry(void *parameter)//线程1入口函数
{while(1)//循环执行{flag1 ++;rt_thread_mdelay(1000);}
}void th2_entry(void *parameter)//线程2入口函数
{while(1){flag1 ++;flag2 ++;    rt_kprintf("flag1:[%d] flag2:[%d]\n",flag1,flag2);rt_thread_mdelay(1000);}
}int main(void)
{//动态创建mutex1 = rt_mutex_create("mutex1", RT_IPC_FLAG_FIFO);if(mutex1 == RT_NULL){LOG_E("mutex1 rt_mutex_create failed...\n");return -ENOMEM;}LOG_D("mutex1 rt_mutex_create successed...\n");th1 = rt_thread_create("th1", th1_entry, NULL, 512, 20, 5);if(th1 == RT_NULL){LOG_E("th1 rt_thread_create failed...\n");return -ENOMEM;}LOG_D("th1 rt_thread_create successed...\n");th2 = rt_thread_create("th2", th2_entry, NULL, 512, 20, 5);if(th2 == RT_NULL){LOG_E("th2 rt_thread_create failed...\n");return -ENOMEM;}LOG_D("th2 rt_thread_create successed...\n");rt_thread_startup(th1);rt_thread_startup(th2);return RT_EOK;
}

上面的代码定义了两个变量，flag1和flag2作为临界区，代码原本的功能是让flag1和flag2同步增加，应该两个值是相等的，创建两个线程同时操作这两个变量，在没有互斥量的情况下，会出现不同步和覆盖的可能，导致两个变量不一致、不连续，如下图结果，flag1 != flag2，因此要加上互斥量进行保护

加上互斥量

#include <rtthread.h>#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>
#include "errno.h"rt_mutex_t mutex1;rt_thread_t th1,th2;int flag1 ,flag2;void th1_entry(void *parameter)//线程1入口函数
{while(1)//循环执行{rt_mutex_take(mutex1, RT_WAITING_FOREVER);//上锁flag1 ++;rt_thread_mdelay(1000);flag2 ++;rt_mutex_release(mutex1);//解锁}
}void th2_entry(void *parameter)//线程2入口函数
{while(1){rt_mutex_take(mutex1, RT_WAITING_FOREVER);//上锁flag1 ++;flag2 ++;rt_mutex_release(mutex1);//解锁rt_kprintf("flag1:[%d] flag2:[%d]\n",flag1,flag2);rt_thread_mdelay(1000);}
}int main(void)
{//动态创建mutex1 = rt_mutex_create("mutex1", RT_IPC_FLAG_FIFO);if(mutex1 == RT_NULL){LOG_E("mutex1 rt_mutex_create failed...\n");return -ENOMEM;}LOG_D("mutex1 rt_mutex_create successed...\n");th1 = rt_thread_create("th1", th1_entry, NULL, 512, 20, 5);if(th1 == RT_NULL){LOG_E("th1 rt_thread_create failed...\n");return -ENOMEM;}LOG_D("th1 rt_thread_create successed...\n");th2 = rt_thread_create("th2", th2_entry, NULL, 512, 20, 5);if(th2 == RT_NULL){LOG_E("th2 rt_thread_create failed...\n");return -ENOMEM;}LOG_D("th2 rt_thread_create successed...\n");rt_thread_startup(th1);rt_thread_startup(th2);return RT_EOK;
}

加上了互斥量对临界区的保护，同一时间，只有一个线程能够对临界区进行操作，操作完成后解锁了，下一个线程才能对临界区进行操作，这样两个变量就能够同步相等了

事件集

事件集也是线程间同步的机制之一，一个事件集可以包含多个事件，利用事件集可以完成一对多，多对多的线程间同步。

一个线程和多个事件的关系可设置为： 其中任意一个事件唤醒 线程，或几个事件都到达后唤醒线程，多个事件集合可以用一个32bit无符号整型变量来表示，变量的每一位代表一个事件，线程通过"逻辑与"或"逻辑或"将一个或多个事件关联起来，形成事件组合

RT-Thread 定义的事件集有以下特点：

1. 事件只与线程相关，事件间相互独立
2. 事件仅用于同步，不提供数据传输功能
3. 事件无排队性，即多次向线程发送同一事件(如果线程还未来得及读走)，其效果等同于只发送一次

事件集的使用和管理

对一个事件集的操作包含：创建/初始化事件集、发送事件、接收事件、删除/脱离事件集

动态创建事件集

动态创建事件集函数

函数的返回值是一个rt_event_t数据类型的结构体，其中结构体中有一个rt_uint32_t数据类型的 set 集合，这个集合里面每一位代表一个事件，因此一个事件集里最多支持32个事件

rt_event_t rt_event_create(const char *name, rt_uint8_t flag)#define RT_IPC_FLAG_FIFO                0x00            /**< FIFOed IPC. @ref IPC. */
#define RT_IPC_FLAG_PRIO                0x01            /**< PRIOed IPC. @ref IPC. */struct rt_event
{struct rt_ipc_object parent;                        /**< inherit from ipc_object */rt_uint32_t          set;                           /**< event set */
};
typedef struct rt_event *rt_event_t;

删除事件集函数

rt_err_t rt_event_delete(rt_event_t event)

静态初始化事件集

静态初始化事件集函数

要创建一个rt_event_t类型的结构体指针作为参数传入

rt_err_t rt_event_init(rt_event_t event, const char *name, rt_uint8_t flag)

事件集脱离函数

rt_err_t rt_event_detach(rt_event_t event)

#include <rtthread.h>#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>
#include "errno.h"rt_event_t event1;struct rt_event event2;int main(void)
{int ret;//动态创建事件集event1 = rt_event_create("event1", RT_IPC_FLAG_FIFO);if(event1 == RT_NULL)//如果创建失败{LOG_E("event1 rt_event_create failed...\n");return -ENOMEM;}LOG_D("event1 rt_event_create successed...\n");//如果创建成功//静态初始化事件集ret = rt_event_init(&event2, "event2", RT_IPC_FLAG_FIFO);if(ret < 0)//如果初始化失败{LOG_E("event2 rt_event_init failed...\n");return ret;}LOG_D("event2 rt_event_init successed...\n");//如果初始化成功return RT_EOK;
}

发送和接收事件

发送事件函数

第一个参数是事件集，第二个参数是事件集中的哪一个事件

rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set);

接收事件函数

第一个参数是事件集，第二个参数是事件集中的哪一个事件，第三个参数是与还是或还是清除了，即接收完这个位后要不要进行清除，第四个参数是超时时间，第五个参数用于存放接收到的值

rt_err_t rt_event_recv(rt_event_t   event,rt_uint32_t  set,rt_uint8_t   opt,rt_int32_t   timeout,rt_uint32_t *recved);
//opt参数                       
#define RT_EVENT_FLAG_AND               0x01            /**< logic and */
#define RT_EVENT_FLAG_OR                0x02            /**< logic or */
#define RT_EVENT_FLAG_CLEAR             0x04            /**< clear flag *///timeout参数
#define RT_WAITING_FOREVER              -1              /**< Block forever until get resource. */
#define RT_WAITING_NO                   0               /**< Non-block. */

事件集实现线程同步实例

#include <rtthread.h>#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>
#include "errno.h"rt_event_t event1;rt_thread_t th1,th2,th3;//分别用一个位来表示事件集中的一个事件
#define EVENT_FLAG_1 (0x1 << 0)//事件1
#define EVENT_FLAG_2 (0x1 << 1)//事件2
#define EVENT_FLAG_3 (0x1 << 2)//事件3void th1_entry(void *parameter)//线程1入口函数
{while(1)//循环执行{rt_event_recv(event1, EVENT_FLAG_1, RT_EVENT_FLAG_CLEAR | RT_EVENT_FLAG_AND, RT_WAITING_FOREVER, NULL);//接收事件1rt_kprintf("th1_entry...\n");rt_event_send(event1, EVENT_FLAG_2);//发送事件2rt_thread_mdelay(1000);}
}void th2_entry(void *parameter)//线程2入口函数
{while(1){rt_event_recv(event1, EVENT_FLAG_2, RT_EVENT_FLAG_CLEAR | RT_EVENT_FLAG_AND, RT_WAITING_FOREVER, NULL);//接收事件2rt_kprintf("th2_entry...\n");rt_event_send(event1, EVENT_FLAG_3);//发送事件3rt_thread_mdelay(1000);}
}void th3_entry(void *parameter)//线程3入口函数
{while(1){rt_event_recv(event1, EVENT_FLAG_3, RT_EVENT_FLAG_CLEAR | RT_EVENT_FLAG_AND, RT_WAITING_FOREVER, NULL);//接收事件3rt_kprintf("th3_entry...\n");rt_event_send(event1, EVENT_FLAG_1);//发送事件1rt_thread_mdelay(1000);}
}int main(void)
{//动态创建事件集event1 = rt_event_create("event1", RT_IPC_FLAG_FIFO);if(event1 == RT_NULL){LOG_E("event1 rt_event_create failed...\n");return -ENOMEM;}LOG_D("event1 rt_event_create successed...\n");th1 = rt_thread_create("th1", th1_entry, NULL, 512, 20, 5);if(th1 == RT_NULL){LOG_E("th1 rt_thread_create failed...\n");return -ENOMEM;}LOG_D("th1 rt_thread_create successed...\n");th2 = rt_thread_create("th2", th2_entry, NULL, 512, 20, 5);if(th2 == RT_NULL){LOG_E("th2 rt_thread_create failed...\n");return -ENOMEM;}LOG_D("th2 rt_thread_create successed...\n");th3 = rt_thread_create("th3", th3_entry, NULL, 512, 20, 5);if(th3 == RT_NULL){LOG_E("th3 rt_thread_create failed...\n");return -ENOMEM;}LOG_D("th3 rt_thread_create successed...\n");rt_thread_startup(th1);rt_thread_startup(th2);rt_thread_startup(th3);rt_event_send(event1, EVENT_FLAG_1);//先发送一次事件1return RT_EOK;
}

可以看到确实是按照线程 1、2、3 顺序执行的

创建一个临界区，观察是否能起到保护临界区的作用

可以看到无论每个线程的延时函数放在哪里，每个线程都是按顺序执行的，对临界区起到了保护，避免了竞态现象的发生