FreeRTOS任务调度(抢占式、协作式、时间片轮转)

最新推荐文章于 2025-03-30 21:46:07 发布
最新推荐文章于 2025-03-30 21:46:07 发布
阅读量2.9k 收藏 61
点赞数 32
文章标签： STM32 freertos 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51963216/article/details/141999410
版权

任务调度

文章目录

前言

FreeRTOS 是一个开源的实时操作系统，它支持多种调度策略，包括协作式（cooperative）和抢占式（preemptive）调度。

一、协作式

在协作式调度中，一旦一个任务开始执行，它将持续运行，直到它自己放弃 CPU 控制权为止。这通常发生在任务主动调用 task delay（等待时间片到期）、task yield（放弃剩余时间片）、或者进入阻塞状态（等待事件或资源）时。协作式调度简化了任务间共享资源的管理，因为开发者可以确保在没有明确放弃 CPU 控制权的情况下，任务不会被中断。但这种模式要求每个任务都必须定期放弃 CPU 控制权，否则可能导致系统响应性能下降。
协作式的调度方式，其本质上是任务在运行一段时间后，自己放弃CPU运行权，让其他任务运行。

在FreeRTOS里，是通过taskYIELD()这个函数实现放弃CPU的。一个典型的协作式任务是在while(1){}大循环的最后，调用taskYIELD()去主动放弃CPU；这时其他处于就绪态的最高优先级的任务才可能运行；如果其他任务都不在就绪状态，那么仍然回到taskYIELD()后面继续运行原来的任务。

在FreeRTOS里taskYIELD()是一种放弃CPU执行权的方法，还可以使用延时函数vTaskDelay，以及等待信号量、消息队列等等。
在这里插入图片描述
这里改成0是协作式
直接看代码

/*FreeRTOS配置*/

/* START_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define START_TASK_PRIO 1                   /* 任务优先级 */
#define START_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            StartTask_Handler;  /* 任务句柄 */
void start_task(void *pvParameters);        /* 任务函数 */

/* TASK1 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK1_PRIO      2                   /* 任务优先级 */
#define TASK1_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task1Task_Handler;  /* 任务句柄 */
void task1(void *pvParameters);             /* 任务函数 */

/* TASK2 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK2_PRIO      4                   /* 任务优先级 */
#define TASK2_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task2Task_Handler;  /* 任务句柄 */
void task2(void *pvParameters);             /* 任务函数 */

/* TASK3 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK3_PRIO      4                   /* 任务优先级 */
#define TASK3_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task3Task_Handler;  /* 任务句柄 */
void task3(void *pvParameters);             /* 任务函数 */

/******************************************************************************************************/


/**
 * @brief       FreeRTOS入口函数
 * @param       无
 * @retval      无
 */
void freertos_demo(void)
{
    
    xTaskCreate((TaskFunction_t )start_task,            /* 任务函数 */
                (const char*    )"start_task",          /* 任务名称 */
                (uint16_t       )START_STK_SIZE,        /* 任务堆栈大小 */
                (void*          )NULL,                  /* 传入给任务函数的参数 */
                (UBaseType_t    )START_TASK_PRIO,       /* 任务优先级 */
                (TaskHandle_t*  )&StartTask_Handler);   /* 任务句柄 */
    vTaskStartScheduler();
}

/**
 * @brief       start_task
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void start_task(void *pvParameters)
{
    taskENTER_CRITICAL();           /* 进入临界区 */
    /* 创建任务1 */
    xTaskCreate((TaskFunction_t )task1,                 /* 任务函数 */
                (const char*    )"task1",               /* 任务名称 */
                (uint16_t       )TASK1_STK_SIZE,        /* 任务堆栈大小 */
                (void*          )NULL,                  /* 传入给任务函数的参数 */
                (UBaseType_t    )TASK1_PRIO,            /* 任务优先级 */
                (TaskHandle_t*  )&Task1Task_Handler);   /* 任务句柄 */
    /* 创建任务2 */
    xTaskCreate((TaskFunction_t )task2,                 /* 任务函数 */
                (const char*    )"task2",               /* 任务名称 */
                (uint16_t       )TASK2_STK_SIZE,        /* 任务堆栈大小 */
                (void*          )NULL,                  /* 传入给任务函数的参数 */
                (UBaseType_t    )TASK2_PRIO,            /* 任务优先级 */
                (TaskHandle_t*  )&Task2Task_Handler);   /* 任务句柄 */
    /* 创建任务3 */
    xTaskCreate((TaskFunction_t )task3,                 /* 任务函数 */
                (const char*    )"task3",               /* 任务名称 */
                (uint16_t       )TASK3_STK_SIZE,        /* 任务堆栈大小 */
                (void*          )NULL,                  /* 传入给任务函数的参数 */
                (UBaseType_t    )TASK3_PRIO,            /* 任务优先级 */
                (TaskHandle_t*  )&Task3Task_Handler);   /* 任务句柄 */
    vTaskDelete(StartTask_Handler); /* 删除开始任务 */
    taskEXIT_CRITICAL();            /* 退出临界区 */
}

/**
 * @brief       task1
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void task1(void *pvParameters)
{
    uint32_t task1_num = 0;
    
    while (1)
    {
       printf("task1\r\n");
        HAL_Delay(100);
    }
}

/**
 * @brief       task2
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void task2(void *pvParameters)
{
    uint32_t task2_num = 0;
    
    while (1)
    {
              printf("task2\r\n");
        HAL_Delay(200);
    }
}

/**
 * @brief       task3
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void task3(void *pvParameters)
{
    uint8_t key = 0;
    
    while (1)
    {
              printf("task3\r\n");
        HAL_Delay(300);
    }
}

先来看这段代码的执行结果
在这里插入图片描述
只有task2在执行，task3和task2是相同优先级 但是task2任务先创建的，task2任务执行后没有放弃CPU使用权，所以其他任务没有机会执行。
这说明了协作式的调度，是需要任务自己放弃CPU的，否则其他任务不能得到运行机会。​
然后我们修改一下代码
在这里插入图片描述
可以看到task2执行完之后把cpu执行权释放了，然后这个时候task3开始执行，由于task3开始执行后没有释放CPU执行权所以，task2任务无法执行
在这里插入图片描述
然后我们在修改一下代码
在这里插入图片描述
可以看到task2和task3交替执行
在这里插入图片描述
可以发现，现在task02和task03都有执行，而task01没有执行。

这是因为task02在执行完后，通过taskYIELD();放弃了CPU；

此时task03和task01都有机会运行，但是task03优先级高，所以task03获得了运行机会；

task03运行完之后，也是通过taskYIELD();放弃了CPU，此时task02和task01有机会运行，但是task02优先级高，task02又获得了运行权。

这样循环执行，由于task01优先级低，它总是得不到运行机会。
如果想要所有任务都执行到，一种可行的方法是使用vTaskDelay指定放弃CPU的时间，如task02中放弃1000周期、tack03中放弃1000周期，那么当这两个任务都被挂起时，task01就获得了运行权。
我们修改一下代码
在这里插入图片描述
可以看到执行结果
在这里插入图片描述

二、时间片轮转

时间片轮转的调度方法，是让相同优先级的几个任务轮流运行，每个任务运行一个时间片，任务在时间片运行完之后，操作系统自动切换到下一个任务运行；在任务运行的时间片中，也可以提前让出CPU运行权，把它交给下一个任务运行（这一点和协作式类似）。
FreeRTOS的时间片固定为一个时钟节拍，由configTICK_RATE_HZ这个宏设置
在这里插入图片描述
把设置改回来，然后修改一下代码
在这里插入图片描述
在这里插入图片描述

可以看到执行结果，各任务都不主动放弃CPU。可以看到，虽然各个任务都没有主动放弃CPU执行权，但是同为高优先级的task02和task03，都得到了运行的机会；只有低优先级的task01没有执行到。这是因为操作系统对两个高优先级的任务使用了时间片轮转调度，轮流得到了执行。
关闭时间片轮转调度功能，即把configUSE_TIME_SLICING宏定义去除或定义为0：
在这里插入图片描述
执行结果如下图所示
在这里插入图片描述
task03又没有机会去执行了。

三、抢占式

抢占式调度允许操作系统根据优先级来决定哪个任务应当获得 CPU 控制权。当一个高优先级任务变为就绪状态时（例如，它正在等待的事件发生了），系统会中断当前运行的较低优先级任务，把 CPU 控制权交给高优先级任务。这确保了对紧急任务的快速响应。在这种模式下，任务不需要显式放弃 CPU 控制权，因为它们可以随时被更高优先级的任务抢占。

抢占式调度，是最高优先级的任务一旦就绪，总能得到CPU的执行权；它抢占了低优先级的运行机会。在抢占式调度系统中，总是运行最高优先级的任务。

抢占式调度的特点在于，可以使得一些需要实时运行的任务，能在较短的时间内获得CPU执行权，保证这些实时任务及时执行。

在FreeRTOS中，抢占式调度，与时间片轮转可以同时存在；当有高优先级任务就绪时，运行高优先级任务；当最高优先级的任务有好几个时，这几个任务可以以时间片轮转方式调度。
我们修改一下代码

在这里插入图片描述

低优先级的task01一直占用CPU，不会主动放弃执行权；task02执行一次，放弃500ms的执行权；task03执行一次，放弃1000ms执行权：
然后看一下结果
在这里插入图片描述

首先task02和task03执行时间片轮转，各执行了一次；然后它们都放弃了CPU执行权，task01得到了执行，在500ms内，它可以执行3次；

到500ms时，task02第一次延时时间到，恢复就绪态，task02抢占了CPU执行，执行完打印后，又进行延时放弃CPU；task01得到了执行；又执行了2次，过去了1000ms,这个时候task02和task03都有机会执行，进行了一次时间片轮转，然后又回到task01执行

到100ms时，task03第一次恢复就绪，task02第二次恢复就绪，都各执行了一遍；之后又让出CPU；task01得到了执行；然后一直循环。

总结

可以看出，开启了抢占式和时间片轮转两种调度算法时，高优先级的任务一旦就绪，就能抢占低优先级的CPU执行权；如果有两个同优先级的任务都可以运行，则它们之间是时间片轮转方式调度。抢占式调度和时间片轮转两种任务的切换方式，可以说是FreeRTOS系统最核心的功能。

FreeRTOS任务调度从入门到精通
大模型大数据攻城狮的专栏
08-13 626
FreeRTOS 任务调度是 FreeRTOS 操作系统的核心功能之一，它负责根据一定的策略和算法，对系统中的多个任务进行合理的分配和处理，以确保系统的稳定性和高效性。在嵌入式系统中，任务调度尤为关键，因为它直接影响到系统的实时性和响应能力。FreeRTOS 任务调度的基本原理主要基于优先级调度算法。在 FreeRTOS 中，每个任务都被赋予一个优先级，任务调度器根据任务的优先级来决定哪个任务应该首先获得处理器的执行权。当系统中有多个任务同时处于就绪状态时，优先级最高的任务将首先被执行。
【花雕学编程】Arduino RTOS 之任务的调度：抢占式、协作式和时间片轮转
雕爷学编程
11-05 675
Arduino还有一个丰富的库和社区，你可以利用它们来扩展Arduino的功能和学习Arduino的知识。在第一个案例中，任务1和任务2的优先级不同，任务2的优先级高于任务1。通过合理的任务调度策略，可以提高系统的效率、响应速度和稳定性，从而满足不同应用场景的需求。通过设置任务的优先级和时间片轮转调度策略，开发者可以控制任务的执行顺序和频率。5、创新：Arduino可以让你用电子的方式来表达你的创意和想象，你可以用Arduino来制作各种有趣和有用的项目，如机器人、智能家居、艺术装置等。
【FreeRTOS】05 任务的调度：抢占式、协作式、时间片轮转
热门推荐
小白白学电子
05-30 1万+
本节来讲一讲FreeRTOS的任务调度，这是操作系统最核心的功能。
FreeRTOS学习（十二）：时间片轮转调度详解 （众生平等！）
最新发布
m0_71304252的博客
03-30 1197
在多任务操作系统中，时间片轮转（Round Robin, RR）是一种常见的任务调度算法。它的核心思想是将处理器的时间分成一个个时间片，每个任务获得一个时间片，在时间片用完之前，任务不能被抢占执行。FreeRTOS 是一个广泛应用的实时操作系统，它提供了时间片轮转的调度机制。本文将通过一个实验案例来介绍 FreeRTOS 的时间片轮转调度原理，并结合代码示例来帮助大家更好地理解如何使用这一调度策略。时间片轮转是一种简单且高效的任务调度算法。
FreeRTOS - 任务调度
luckyme_的博客
10-17 3899
FreeRTOS学习过程中内容整理：综合韦东山-FreeRTOS手册和视频、野火-FreeRTOS内核实现与应用开发、及网上查找的其他资源整理而得。
RTOS系统 -- FreeRTOS之任务调度
sz66cm 学习随笔
07-09 804
FreeRTOS是一种轻量级的实时操作系统，被广泛应用于嵌入式系统中。它提供了多任务管理功能，包括任务创建、任务调度和任务切换。FreeRTOS的调度器根据任务的优先级和状态自动调度任务，确保系统资源的有效利用和实时性。在M4处理器上，FreeRTOS能够实现任务间的自动调度。调度器采用基于优先级的抢占式调度算法，确保系统总是运行最高优先级且处于就绪状态的任务。如果有多个任务具有相同的优先级，调度器会采用时间片轮转的方法在这些任务之间切换。
FreeRTOS学习——任务调度
qq_47172243的博客
01-09 3606
1. 高优先级任务，优先执行；2. 高优先级任务不停止，低优先级任务无法执行；3. 被抢占的任务将会进入就绪态。
FreeRTOS任务调度器
2301_78772787的博客
05-10 1588
任务调度器是实时操作系统（RTOS）的一个关键组件，它负责决定在多个可运行任务中哪一个将获得CPU时间得以执行。它基于任务的优先级和状态来做出这些决定。在一个RTOS中，可能会有多个任务同时运行，但是在任意时刻，CPU只能执行一个任务。任务调度器的主要目标是按照系统的需求合理分配CPU时间。调度器就是使用相关的调度算法来决定当前需要执行的哪个任务。基本功能任务的选择任务调度器会根据预设的算法从所有可运行的任务中选择一个要执行的任务。任务的优先级任务通常会被分配一个优先级，
FreeRTOS任务调度
学嵌入式的一波
07-24 2621
抢占式，时间片、合作式实际应用主要是和，合作式调度用到的很少。
STM32H743 FreeRTOS实现时间片调度【支持STM32H7系列单片机_FreeRTOS操作系统】.zip
01-30
2. **任务调度**：FreeRTOS的任务调度器是抢占式的，这意味着高优先级任务一旦就绪，可以立即打断正在执行的低优先级任务。时间片轮转是通过设置每个任务的时间量子来实现的，当一个任务的时间片用完后，调度器会...
【花雕学编程】Arduino RTOS 之抢占式任务调度
雕爷学编程
11-08 957
Arduino还有一个丰富的库和社区，你可以利用它们来扩展Arduino的功能和学习Arduino的知识。您的硬件平台、使用场景和Arduino版本可能影响使用方法的选择。Arduino平台以其简洁的编程接口和丰富的扩展功能，成为了电子爱好者、设计师、工程师和艺术家们的首选工具。通过合理配置任务的优先级及延时，开发者可以优化系统的整体性能，确保实时任务的执行。5、创新：Arduino可以让你用电子的方式来表达你的创意和想象，你可以用Arduino来制作各种有趣和有用的项目，如机器人、智能家居、艺术装置等。
Freertos 任务调度
m0_65731372的博客
02-10 2107
Freertos 任务调度
FreeRTOS-实现任务调度器
k666499436的博客
10-04 1万+
本文正式开启对FreeRTOS内核的研究，首当其冲的就是就是任务调度器的实现，任务调度器作为FreeRTOS的核心，因为FreeRTOS的本质就是任务的轮流运行，为了循序渐进的学习，避免一口吃成一个大胖子，本文只实现两个任务的切换，先不管任务的优先级，本文的目的就是将任务切换的全过程分析的透透彻彻，在此之前要深入理解FreeRTOS链表操作，还有ARM架构的知识，我已经帮你们总结好了。《FreeRTOS-链表的源码解析》《FreeRTOS-ARM架构与程序的本质》《FreeRTOS-ARM架构深入理解》
【FreeRTOS篇】任务调度
m0_66492811的博客
08-19 953
任务调度
freertos 任务调度—抢占式， 时间片
陌上花开缓缓归以的博客
09-11 1206
每个任务都有不同的优先级， 任务会一直运行直到被高优先级任务抢占或者遇到阻塞式的 API 函数，比如 vTaskDelay（延迟，事件标志等待，信号量等待）才会切换到其他任务。而在时间片轮询的过程中如果调用了阻塞式 API 函数， 调用函数时， 虽然 5 个系统时钟节拍的时间片大小还没有用完， 此时依然会通过时间片调度切换到下一个任务。每个任务都有相同的优先级， 任务会运行固定的时间片个数或者遇到阻塞式的 API 函数，比如。由于任务2的优先级高于任务1，因此任务2将首先运行。
freertos学习之路3-freertos的任务调度
留下虚度光阴的一些证据。
02-05 2415
freertos的任务调度介绍
FreeRTOS-任务调度
qq628383的博客
04-15 767
1.系统配置完成systick模块后，通常下每当产生一个systick中断就会运行SysTick_Handler。 2.分析void xPortSysTickHandler( void ) a.通过操作寄存器basepri关闭一些中端 b.通过xTaskIncrementTick判断是否需要进行一次任务切换 c.打开在步骤a中关闭的中断 下面具体分析函数BaseType_t...
FreeRTOS如何实现基于优先级的抢占式任务调度？请结合源代码进行说明。
11-11
FreeRTOS中的基于优先级的抢占式任务调度是通过任务控制块（TCB）和调度器的协作来实现的。每个任务都有一个TCB，其中包含了任务的状态信息和任务控制数据。当系统初始化时，所有任务的TCB被创建并添加到就绪列表中。调度器会根据任务的优先级来决定哪个任务获得处理器时间片。 参考资源链接：[FreeRTOS实时内核实战指南](https://wenku.csdn.net/doc/6412b79ebe7fbd1778d4af28?spm=1055.2569.3001.10343) 在FreeRTOS中，调度器是一个非常核心的部分，它负责任务的切换和调度。当一个高优先级的任务变为就绪状态时，调度器会检查它是否具有比当前正在运行的任务更高的优先级。如果是，调度器会执行一次上下文切换，将CPU的控制权从当前任务转移到高优先级的任务。这个过程是实时操作系统响应外部事件的关键所在。 具体到源代码层面，FreeRTOS调度器的核心功能是实现于`vTaskSwitchContext`函数中。这个函数会在任务切换时被调用，其目的是根据任务优先级来选择下一个将要运行的任务。它通过比较就绪列表中任务的优先级来完成这一工作，一旦找到一个优先级更高的就绪任务，就会执行上下文切换。 例如，当一个高优先级任务完成延时等待并变为就绪状态时，它会触发调度器进行任务切换。具体代码实现可能如下： ```c void vTaskSwitchContext( void ) { // ... 省略部分代码 ... // 检查是否有优先级更高的任务就绪 if( pxReadyTasksLists[ uxTopReadyPriority ] != NULL ) { // 找到就绪列表中的第一个任务，并准备进行上下文切换 pxCurrentTCB = ( TCB_t * ) pxReadyTasksLists[ uxTopReadyPriority ]; // ... 省略部分代码 ... // 执行上下文切换，这里通常涉及到汇编语言的调用，以保存和恢复任务的上下文 portYIELD_WITHIN_API(); } } ``` 需要注意的是，实际的上下文切换过程涉及到处理器特定的寄存器保存和恢复操作，这部分代码通常是用汇编语言编写的，以确保切换过程的效率和正确性。在x86、ARM等不同架构的处理器上，这些代码会有所不同。 通过理解FreeRTOS的调度策略和源代码，开发者能够更好地掌握如何在实际的嵌入式项目中利用FreeRTOS来实现高效的任务调度和系统设计。此外，为了深入学习FreeRTOS的各项功能和优化方法，建议阅读《FreeRTOS实时内核实战指南》中文版。这本指南不仅详细介绍了任务调度的原理，还提供了实用的项目案例和技巧，有助于开发者进一步提升嵌入式开发的实战能力。 参考资源链接：[FreeRTOS实时内核实战指南](https://wenku.csdn.net/doc/6412b79ebe7fbd1778d4af28?spm=1055.2569.3001.10343)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我与nano

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值