RT-Thread-RT-Thread 夏令营IPC机制学习笔记（day3）RT-Thread问答社区

RT-Thread 夏令营IPC机制学习笔记（day3）

发布于 2024-07-30 21:43:56 浏览：387 订阅该版

#IPC机制
1.线程间同步：信号量、互斥量、事件集
2.线程间通信：邮箱、消息队列、信号

##线程间同步
###信号量
  信号量(Semaphore)是一种轻型的用于解决线程间同步问题的内核对象，一个或多个运行线程可以获取或释放它,从而达到同步或互斥的目的。

信号量一般分为三种：
1.互斥信号量
用于解决互斥问题。它比较特殊，可能会引起优先级反转问题
2.二值信号量
用于解决同步问题
3.计数信号量
用于解决资源计数问题
####二值信号量
二值信号量主要用于线程与线程之间、线程与中断服务程序(ISR)之间的同步。
1.用于同步的二值信号量初始值为0，表示同步事件尚未产生;
2.线程获取信号量以等待该同步事件的发生;
3.另一个任务或 ISR到达同步点时，释放信号量(将其值设置为1)表示同步事件已发生，唤醒等待的任务。

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240730/bce73d496ef21666947747fff9a2231d.png.webp)
####计数信号量
1.计数信号量用于控制系统中共享资源的多个实例的使用，允许多个线程同时访问同一种资源的多个实例。
2.计数信号量被初始化为n(非负整数)，n为该种共享资源的数目。

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240730/3fd04df2232dab0d7fa11bcb168a5f8e.png.webp)
###互斥量
互斥量又叫相互排斥的信号量，是一种特殊的二值信号量。它和信号量不同的是，它支持:
1.互斥量所有权;
2.递归访问;
3.防止优先级翻转的特性。
###事件集
1.创建/初始化事件集
2.删除/脱离事件集
3.获取/释放事件集
##线程间通信
###消息邮箱
邮箱中的每一封邮件只能容纳固定的 4 字节内容(针对 32 位处理系统，指针的大小即为 4 个字节，所以一封邮件恰好能够容纳一个指针)。典型的邮箱也称作交换消息，如下图所示，线程或中断服务例程把一封4 字节长度的邮件发送到邮箱中，而一个或多个线程可以从邮箱中接收这些邮件并进行处理。

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240730/417ecfea7305312e8cdada57e9b7211c.png.webp)
###消息队列
消息队列，也就是将多条消息排成的队列形式，是一种常用的线程间通信方式可以应用在多种场合，线程间的消息交换，使用串口接收不定长数据等。线程可以将一条或多条消息放到消息队列中，同样一个或多个线程可以从消息队列中获得消息;同时消息队列提供异步处理机制可以起到缓冲消息的作用。

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240730/29dcbd52692414956515b7546567ca76.png.webp)
#临界区
临界区的资源在同一时间只能被一个线程(住户)使用，所以一旦临界资源被占用，其他的线程(住户)能做的就只有等待。如下图所示：

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240730/19bba03324a135ece3dc3c678692048a.png.webp)
#死锁
两个线程互相等着对方给自己资源,于是造成了死锁

```c
#include <board.h>
#include <rtthread.h>
#include <drv_gpio.h>
#ifndef RT_USING_NANO
#include <rtdevice.h>
#endif /* RT_USING_NANO */

#define THREAD_PRIORITY         25
#define THREAD_TIMESLICE        5

#define GPIO_LED_B    GET_PIN(F, 11)
#define GPIO_LED_R    GET_PIN(F, 12)

/* 指向信号量的指针 */
static rt_sem_t dynamic_sem = RT_NULL;

rt_align(RT_ALIGN_SIZE)
static char thread1_stack[1024];
static struct rt_thread thread1;
static void rt_thread1_entry(void *parameter)
{
    static rt_uint8_t count = 0;
    rt_pin_mode(GPIO_LED_R, PIN_MODE_OUTPUT);

while(1)
    {
        if(count <= 100)
        {
            count++;
        }
        else
            return;

/* count 每计数 10 次，就释放一次信号量 */
         if(0 == (count % 10))
        {
            rt_kprintf("t1 release a dynamic semaphore.\n");
            rt_sem_release(dynamic_sem);
            rt_pin_write(GPIO_LED_R, PIN_HIGH);
            rt_thread_mdelay(500);
            rt_pin_write(GPIO_LED_R, PIN_LOW);
            rt_thread_mdelay(500);
        }
    }
}

rt_align(RT_ALIGN_SIZE)
static char thread2_stack[1024];
static struct rt_thread thread2;
static void rt_thread2_entry(void *parameter)
{
    static rt_err_t result;
    static rt_uint8_t number = 0;
    rt_pin_mode(GPIO_LED_B, PIN_MODE_OUTPUT);
    while(1)
    {
        /* 永久方式等待信号量，获取到信号量，则执行 number 自加的操作 */
        result = rt_sem_take(dynamic_sem, RT_WAITING_FOREVER);
        if (result != RT_EOK)
        {
            rt_kprintf("t2 take a dynamic semaphore, failed.\n");
            rt_sem_delete(dynamic_sem);
            return;
        }
        else
        {
            number++;
            rt_kprintf("t2 take a dynamic semaphore. number = %d\n" ,number);
            rt_sem_release(dynamic_sem);
            rt_pin_write(GPIO_LED_B, PIN_HIGH);
            rt_thread_mdelay(500);
            rt_pin_write(GPIO_LED_B, PIN_LOW);
            rt_thread_mdelay(500);
        }
    }
}

/* 信号量示例的初始化 */
int semaphore_sample(void)
{
    /* 创建一个动态信号量，初始值是 0 */
    dynamic_sem = rt_sem_create("dsem", 0, RT_IPC_FLAG_PRIO);
    if (dynamic_sem == RT_NULL)
    {
        rt_kprintf("create dynamic semaphore failed.\n");
        return -1;
    }
    else
    {
        rt_kprintf("create done. dynamic semaphore value = 0.\n");
    }

rt_thread_init(&thread1,
                   "thread1",
                   rt_thread1_entry,
                   RT_NULL,
                   &thread1_stack[0],
                   sizeof(thread1_stack),
                   THREAD_PRIORITY, THREAD_TIMESLICE);
    rt_thread_startup(&thread1);

rt_thread_init(&thread2,
                   "thread2",
                   rt_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(semaphore_sample, semaphore sample);

int main(void)
{
    return 0;
}
```