遇到一个信号量的问题

发布于 2023-04-23 19:52:37 浏览：804 订阅该版

4 个回答

lchnu 2023-04-23

Witness, Understand, Skill

`RT-Thread运行处于就绪态的最高优先级线程。`

按照你的设置，且假设timer线程不存在的情况下（存在与否，对你的结果没有影响），线程优先级从高到低，分别是
> demo_02，为9；demo_01, main，均为10；tshell，为20

**在Finsh中调用single函数**

1. tshell线程的优先级是20。single函数是优先级为20的tshell线程中调用的。
2. rt_thread_init创建线程后，两个线程的状态都是INIT状态，而不是就绪态
3. single函数使用startup(&tid)后，将demo_01变成就绪，demo_01剥夺tshell线程的CPU使用权
4. demo_01中release信号量后，会进行线程切换，但是demo_01依然是处于`就绪态的最高优先级任务`，不会释放CPU
5. demo_01运行10次，退出了线程，CPU使用权依次交回给main -> tshell线程
6. tshell线程运行startup(&tid2),将demo_02变成就绪，demo_02剥夺tshell线程的CPU使用权
7. demo_02运行10次，每次都能take成功信号量

**将single函数的内容写入到main线程中**

1. main线程的优先级是10
2. rt_thread_init创建线程后，两个线程的状态都是INIT状态，而不是就绪态
3. main线程使用startup(&tid)后，将demo_01变成就绪。但因为它和main是同优先级，main线程没有任何放弃CPU的行为，所以，CPU使用权不会从main中交出去
4. main线程继续startup(&tid)后，将demo_02变成就绪。由于demo_02的优先级是9，高于main，所以demo_02剥夺main线程的CPU使用权
5. demo_02打印task 02 demo，take信号量，没有信号量release，demo_02从就绪态变成Suspend状态，交出CPU使用权
6. demo_01拿到CPU使用权，打印task 01 demo, 释放1次信号量，且产生线程切换到demo_02
7. demo_01和demo_02交替打印

下方有个链接，是前几天我对相同问题的回复，供参考。
https://club.rt-thread.org/ask/question/d59eb4f4fa9c5a3e.html

在论坛中交流，建议养成贴代码的习惯，更方便大家交流沟通。

我在下方给你贴的代码中，添加了调度器的钩子函数，你可以更加清晰地从输出信息中看到线程切换过程。

```c
/*
 * Copyright (c) 2006-2023, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2023-04-23     lchnu    first version
 */

#include <rtthread.h>

#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>

#define SEMAPHORE_DEMO_IN_MAIN

rt_sem_t dynamic_sem;

void thread_demo_01(void *arg)
{
    static rt_uint8_t count = 0;
    rt_kprintf("thread1 demo\n");

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);
        }
    }
}

void thread_demo_02(void *arg)
{
    static rt_err_t result;
    static rt_uint8_t number = 0;
    rt_kprintf("thread2 demo\n");
    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);
        }
    }
}

static void hook_of_scheduler(struct rt_thread* from, struct rt_thread* to)
{
    rt_kprintf("from: %s -->  to: %s \n", from->name , to->name);
}

int main(void)
{
#ifdef SEMAPHORE_DEMO_IN_MAIN
    rt_thread_t tid1, tid2;
    rt_scheduler_sethook(hook_of_scheduler);

dynamic_sem = rt_sem_create("dsem", 0, RT_IPC_FLAG_FIFO);
    tid1 = rt_thread_create("thread1", thread_demo_01, RT_NULL, 1024, 10, 20);
    tid2 = rt_thread_create("thread2", thread_demo_02, RT_NULL, 1024, 9, 20);
    rt_thread_startup(tid1);
    rt_thread_startup(tid2);
#endif

return RT_EOK;
}

#ifndef SEMAPHORE_DEMO_IN_MAIN
int single(int argc, char *argv[])
{
    rt_thread_t tid1, tid2;
    rt_scheduler_sethook(hook_of_scheduler);
    dynamic_sem = rt_sem_create("dsem", 0, RT_IPC_FLAG_FIFO);
    tid1 = rt_thread_create("thread1", thread_demo_01, RT_NULL, 1024, 10, 20);
    tid2 = rt_thread_create("thread2", thread_demo_02, RT_NULL, 1024, 9, 20);
    rt_thread_startup(tid1);
    rt_thread_startup(tid2);

return 0;
}

MSH_CMD_EXPORT(single, test semaphore);
#endif
```

最后，你可以尝试一下，**使用Finsh方式创建两个线程，但是将demo_01的优先级从10改成25，得到的结果就和官方例程一样了。**

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230423/389f47279d32b36dacb086f1c0a1033f.png.webp)

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20230423/6769da3e6554c6247c1cc7812966d898.png.webp)