为什么单核CPU能同时执行多个任务？比如我们在听歌的同时还可以和别人聊天，CPU是如何做到的呢？其实这个主要依靠任务调度算法，而调度算法只是宏观上让人感觉多个任务在同时执行，但是微观上单核CPU其实任然还是没有实现的，它只是让任务被轮流执行，只是切换的频率非常高，人感觉不到而已。当然多核CPU就无所谓了。
下面我将介绍三种常见的调度算法的C语言代码实现，循环调度、优先级调度和时间片轮转调度，并进行简要讲解。

  • 循环调度算法：
  1. #include <stdio.h>
  3. #define NUM_TASKS 3
  4. // 任务函数类型定义
  5. typedef void (*TaskFunc)();
  7. // 任务结构体
  8. typedef struct {
  9.     TaskFunc func;  // 任务函数指针
  10.     int period;     // 任务执行周期
  11. } Task;
  13. // 任务函数示例
  14. void task1() {
  15.     printf("Task 1\n");
  16. }
  18. void task2() {
  19.     printf("Task 2\n");
  20. }
  22. void task3() {
  23.     printf("Task 3\n");
  24. }
  26. int main() {
  27.     Task tasks[NUM_TASKS] = {
  28.         {task1, 1000},   // 任务1，执行周期为1000ms
  29.         {task2, 2000},   // 任务2，执行周期为2000ms
  30.         {task3, 3000}    // 任务3，执行周期为3000ms
  31.     };
  33.     while (1) {
  34.         for (int i = 0; i < NUM_TASKS; i++) {
  35.             tasks[i].func();   // 执行当前任务
  36.             delay(tasks[i].period);  // 延时任务周期
  37.         }
  38.     }
  39.     return 0;
  40. }
循环调度算法按照固定的顺序依次执行每个任务，并通过延时函数控制每个任务的执行周期。在上面的代码中，定义了3个任务，每个任务具有不同的执行周期。main函数中的while循环会不断执行任务，并通过delay函数进行延时。

  • 优先级调度算法：
  1. #include <stdio.h>
  3. #define NUM_TASKS 3
  5. // 任务函数类型定义
  6. typedef void (*TaskFunc)();
  8. // 任务结构体
  9. typedef struct {
  10.     TaskFunc func;  // 任务函数指针
  11.     int priority;   // 任务优先级
  12. } Task;
  14. // 任务函数示例
  15. void task1() {
  16.     printf("Task 1\n");
  17. }
  19. void task2() {
  20.     printf("Task 2\n");
  21. }
  23. void task3() {
  24.     printf("Task 3\n");
  25. }
  27. int main() {
  28.     Task tasks[NUM_TASKS] = {
  29.         {task1, 1},   // 任务1，优先级为1
  30.         {task2, 2},   // 任务2，优先级为2
  31.         {task3, 3}    // 任务3，优先级为3
  32.     };
  34.     while (1) {
  35.         for (int i = 0; i < NUM_TASKS; i++) {
  36.             if (tasks[i].priority == 1) {
  37.                 tasks[i].func();   // 执行优先级最高的任务
  38.                 delay(tasks[i].period);  // 延时任务周期
  39.             }
  40.         }
  41.         for (int i = 0; i < NUM_TASKS; i++) {
  42.             if (tasks[i].priority == 2) {
  43.                 tasks[i].func();   // 执行次高优先级的任务
  44.                 delay(tasks[i].period);  // 延时任务周期
  45.             }
  46.         }
  47.         for (int i = 0; i < NUM_TASKS; i++) {
  48.             if (tasks[i].priority == 3) {
  49.                 tasks[i].func();   // 执行最低优先级的任务
  50.                 delay(tasks[i].period);  // 延时任务周期
  51.             }
  52.         }
  53.     }
  55.     return 0;
  56. }
优先级调度算法根据任务的优先级依次执行任务。在上面的代码中，定义了3个任务，每个任务具有不同的优先级。

  • 时间片轮转调度算法：
  1. #include <stdio.h>
  3. #define NUM_TASKS 3
  4. #define TIME_QUANTUM 1000
  6. // 任务函数类型定义
  7. typedef void (*TaskFunc)();
  9. // 任务结构体
  10. typedef struct {
  11.     TaskFunc func;   // 任务函数指针
  12.     int remaining_time;   // 任务剩余执行时间
  13. } Task;
  15. // 任务函数示例
  16. void task1() {
  17.     printf("Task 1\n");
  18. }
  20. void task2() {
  21.     printf("Task 2\n");
  22. }
  24. void task3() {
  25.     printf("Task 3\n");
  26. }
  28. int main() {
  29.     Task tasks[NUM_TASKS] = {
  30.         {task1, 2000},   // 任务1，执行时间为2000ms
  31.         {task2, 3000},   // 任务2，执行时间为3000ms
  32.         {task3, 4000}    // 任务3，执行时间为4000ms
  33.     };
  35.     int current_task = 0;
  37.     while (1) {
  38.         if (tasks[current_task].remaining_time > 0) {
  39.             tasks[current_task].func();   // 执行当前任务
  40.             tasks[current_task].remaining_time -= TIME_QUANTUM;
  41.         }
  42.         current_task = (current_task + 1) % NUM_TASKS;   // 切换到下一个任务
  43.         delay(TIME_QUANTUM);   // 延时时间片长度
  44.     }
  46.     return 0;
  47. }
时间片轮转调度算法将CPU的执行时间划分为固定长度的时间片，并依次执行每个任务，当一个任务的时间片用完后，切换到下一个任务。在上面的代码中，定义了3个任务，每个任务具有不同的执行时间。
以上是常见的嵌入式开发中多任务调度算法的C语言代码实现示例。每种调度算法都有不同的特点和适用场景，根据实际需求选择合适的调度算法能够提高嵌入式系统的性能和效率。

来源：头条号 晓亮Albert