RT_thread（八）信号量的使用

IPC

• 在嵌入式系统中运行的代码主要包括线程和ISR，在它们的运行过程中，它们的运行步骤有时需要同步（按照预定的先后次序运行），它们访问的资源有时需要互斥（一个时刻只允许一个线程访问资源），它们之间有时也要彼此交换数据。这些需求，有的是因为应用需求，有的是多线程编程模型带来的需求。
• 操作系统必须提供相应的机制来完成这些功能，我们把这些机制统称为进（线）程间通信（Internal Process Communication IPC），RT-Thread中的IPC机制包括信号量、互斥量、事件、邮箱、消息队列
• 通过IPC机制，我们可以协调多个线程（包括ISR）“默契”的工作，从而共同完成一个整项工作。

举例信号量

以生活中的停车场为例来理解信号量的概念：

①当停车场空的时候， 停车场的管理员发现有很多空车位， 此时会让外面的车陆续进入停车场获得停车位；

②当停车场的车位满的时候， 管理员发现已经没有空车位， 将禁止外面的车进入停车场， 车辆在外排队等候；

③当停车场内有车离开时， 管理员发现有空的车位让出， 允许外面的车进入停车场； 待空车位填满后， 又禁止外部车辆进入。

在此例子中，管理员就相当于信号量；管理员手中空车位的个数就是信号量的值 ；停车位相当于公共资源 ， 车辆相当于线程。 车辆通过获得管理员的允许取得停车位， 就类似于线程通过获得信号量访问公共资源

信号量工作机制

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

信号量工作示意图如上图所示，每个信号量对象都有一个信号量值和一个线程等待队列，信号量的值对应信号量对象的实例数目（资源数目），假如信号量值N，则表示共有 N 个信号量实例（资源）可以被使用，当信号量实例数目为零时，再请求该信号量的线程就会被挂起在该信号量的等待队列上，等待可用的信号量实例（资源）

信号量的控制块

在 RT-Thread 中，信号量控制块是操作系统用于管理信号量的一个数据结构。

struct rt_semaphore
      {
          struct rt_ipc_object parent;  /**< inherit from ipc_object */
          rt_uint16_t          value;  /**< value of semaphore. */
      };

定义静态信号量：struct rt_semaphore static_sem

• 初始化与脱离

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

定义动态信号量：rt_sem_t dynamic_sem

• 创建与删除

rt_sem_t rt_sem_create(const char *name,
						 rt_uint32_t value, 
						 rt_uint8_t flag)
				  //RT_IPC_FLAG_FIFO   RT_IPC_FLAG_PRIO
rt_err_t rt_sem_delete(rt_sem_t sem)     

• 获取信号量

rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time)  
						//RT_WAITING_FOREVER=-1
rt_err_t rt_sem_trytake(rt_sem_t sem)

• 释放信号量

rt_err_t rt_sem_release(rt_sem_t sem)

semaphore_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
 */

/*
 * 程序清单：信号量例程
 *
 * 该例程创建了一个动态信号量，初始化两个线程，线程1在count每计数10次时，
 * 发送一个信号量，线程2在接收信号量后，对number进行加1操作
 */
#include <rtthread.h>

#define THREAD_PRIORITY         25
#define THREAD_TIMESLICE        5

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

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;

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

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

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;
    while (1)
    {
        /* 永久方式等待信号量，获取到信号量，则执行number自加的操作 */
        result = rt_sem_take(dynamic_sem, RT_WAITING_FOREVER);
        if (result != RT_EOK)
        {
            rt_kprintf("thread2 take a dynamic semaphore, failed.\n");
            rt_sem_delete(dynamic_sem);
            return;
        }
        else
        {
            number++;
            rt_kprintf("thread2 take a dynamic semaphore. number = %d\n", number);
        }
    }
}

/* 信号量示例的初始化 */
int semaphore_sample()
{
    /* 创建一个动态信号量，初始值是0 */
    dynamic_sem = rt_sem_create("dsem", 0, RT_IPC_FLAG_FIFO);
    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);