C 语言本身并没有一个叫做 "task"（任务）的内置关键字或数据类型。 "任务" 是一个更高级的、源自操作系统和实时系统领域的概念，在 C 语言中，我们通过一系列的编程技术、库函数和设计模式来模拟、创建和管理任务。
（图片来源网络，侵删）
理解 "tasking in C" 实际上是理解如何在 C 语言中实现并发、多任务和实时处理。
什么是“任务”？
在计算机科学中,一个“任务”可以理解为一个独立的、可以并发执行的执行单元，它与“进程”和“线程”密切相关：
- 进程：操作系统进行资源分配和调度的基本单位，每个进程都有自己独立的内存空间，进程间的通信比较复杂。
- 线程：进程内的一个执行流，是 CPU 调度的基本单位，同一进程内的线程共享该进程的内存空间，创建和切换的开销比进程小。
- 任务：这是一个更抽象的概念，在嵌入式系统和实时操作系统中，一个“任务”通常就是一个线程，或者是一个协作式调度的执行单元，它有自己的栈、上下文和优先级。
在 C 语言中实现任务的核心方法
在 C 语言中，主要有以下几种方法来实现和管理任务：
基于操作系统 API（最常见）
如果你的 C 程序运行在支持多线程的操作系统上（如 Windows, Linux, macOS），你可以直接使用操作系统提供的 API 来创建和管理任务（线程）。
（图片来源网络，侵删）
A. Windows 平台 (使用 windows.h)
在 Windows 中，任务通常用“线程”来实现。
示例代码：创建两个简单的任务（线程）
#include <stdio.h>
#include <windows.h> // Windows API 头文件
// 任务函数的签名必须 DWORD WINAPI FunctionName(LPVOID lpParam)
DWORD WINAPI Task1(LPVOID lpParam) {
for (int i = 0; i < 5; i++) {
printf("Task 1 is running... Count: %d\n", i);
Sleep(1000); // 休眠1000毫秒
}
return 0;
}
DWORD WINAPI Task2(LPVOID lpParam) {
for (int i = 0; i < 5; i++) {
printf("Task 2 is running... Count: %d\n", i);
Sleep(500); // 休眠500毫秒
}
return 0;
}
int main() {
HANDLE hThread1, hThread2;
// 创建线程 (任务)
hThread1 = CreateThread(NULL, 0, Task1, NULL, 0, NULL);
hThread2 = CreateThread(NULL, 0, Task2, NULL, 0, NULL);
if (hThread1 == NULL || hThread2 == NULL) {
printf("Failed to create threads.\n");
return 1;
}
// 等待线程执行完毕
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
// 关闭线程句柄
CloseHandle(hThread1);
CloseHandle(hThread2);
printf("All tasks have finished.\n");
return 0;
}
关键点：
CreateThread: 创建一个新线程。DWORD WINAPI ...: 线程函数的标准格式。Sleep: 让当前线程放弃 CPU，进入等待状态。WaitForSingleObject: 主线程等待子线程结束。HANDLE: 线程的“句柄”，用于操作系统管理该线程。
B. Linux/Unix 平台 (使用 pthread.h)
在 Linux 等类 Unix 系统中，使用 POSIX 线程库，简称 Pthreads。
（图片来源网络，侵删）
示例代码：创建两个简单的任务（线程）
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h> // Pthreads 头文件
// 任务函数的签名必须是 void* FunctionName(void* arg)
void* Task1(void* arg) {
for (int i = 0; i < 5; i++) {
printf("Task 1 is running... Count: %d\n", i);
sleep(1); // 休眠1秒
}
return NULL;
}
void* Task2(void* arg) {
for (int i = 0; i < 5; i++) {
printf("Task 2 is running... Count: %d\n", i);
usleep(500000); // 休眠500,000微秒 (0.5秒)
}
return NULL;
}
int main() {
pthread_t t1, t2;
// 创建线程
if (pthread_create(&t1, NULL, Task1, NULL) != 0) {
perror("Failed to create thread 1");
return 1;
}
if (pthread_create(&t2, NULL, Task2, NULL) != 0) {
perror("Failed to create thread 2");
return 1;
}
// 等待线程结束
pthread_join(t1, NULL);
pthread_join(t2, NULL);
printf("All tasks have finished.\n");
return 0;
}
关键点：
pthread_create: 创建一个新线程。void* ...: 线程函数的标准格式。sleep: 让当前线程休眠。pthread_join: 主线程等待子线程结束。pthread_t: 线程的数据类型。
基于实时操作系统
在嵌入式领域（如单片机、工业控制），我们通常使用专门的实时操作系统，这些系统为 C 语言提供了更强大、更专业的任务管理功能。
常见的 RTOS 有：FreeRTOS, uC/OS, RT-Thread 等。
以 FreeRTOS 为例：
FreeRTOS 提供了明确的任务创建和管理 API。
示例代码：创建两个 FreeRTOS 任务
#include <stdio.h>
#include "FreeRTOS.h" // FreeRTOS 头文件
#include "task.h"
// 任务函数
void Task1Function(void* pvParameters) {
while (1) { // 任务通常是无限循环
printf("Task 1 is running...\n");
vTaskDelay(pdMS_TO_TICKS(1000)); // 延时1秒，不占用CPU
}
}
void Task2Function(void* pvParameters) {
while (1) {
printf("Task 2 is running...\n");
vTaskDelay(pdMS_TO_TICKS(500)); // 延时0.5秒
}
}
int main(void) {
// 创建任务
// xTaskCreate(函数, 任务名, 栈大小, 参数, 优先级, 任务句柄)
xTaskCreate(Task1Function, "Task1", 128, NULL, 1, NULL);
xTaskCreate(Task2Function, "Task2", 128, NULL, 1, NULL);
// 启动调度器，开始多任务执行
// vTaskStartScheduler() 不会返回
vTaskStartScheduler();
// 正常情况下，代码不会执行到这里
for (;;);
return 0;
}
关键点：
- 明确的任务概念：
xTaskCreate就是用来创建任务的。 - 优先级：每个任务都可以有优先级，高优先级的任务可以抢占低优先级任务的 CPU。
- 延时函数：
vTaskDelay是一个非阻塞延时，任务进入阻塞态，让出 CPU，其他任务可以运行，这是实现高效多任务的关键。 - 调度器：
vTaskStartScheduler启动 RTOS 的核心调度器，由它来决定哪个任务在何时获得 CPU。
自己实现（裸机环境）
在没有操作系统支持的“裸机”环境下，我们也可以自己用 C 语言实现一个简单的任务调度器，这通常被称为“前后台系统”或“协作式调度”。
核心思想：
- 任务函数：每个任务都是一个无限循环的函数。
- 调度器：一个主循环，依次调用每个任务函数。
- 任务切换：任务函数内部需要主动调用
yield()或类似函数来“让出” CPU，以便调度器可以执行下一个任务。
示例代码：一个简单的轮询调度器
#include <stdio.h>
#include <stdint.h>
// 定义任务函数类型
typedef void (*TaskFunc)(void);
// 任务函数
void task1() {
static uint32_t count = 0;
printf("Task 1: %lu\n", count++);
}
void task2() {
static uint32_t count = 0;
printf("Task 2: %lu\n", count++);
}
// 简单的 yield 函数，可以是空，也可以做一些超时检查
void yield() {
// 在这里可以添加非阻塞的延时逻辑
// 检查一个定时器是否超时
}
// 任务调度器
void scheduler() {
while (1) {
task1();
yield(); // task1 主动让出 CPU
task2();
yield(); // task2 主动让出 CPU
}
}
int main() {
printf("Simple cooperative scheduler started.\n");
scheduler(); // 启动调度器
return 0;
}
局限性：
- 非抢占式：如果一个任务忘记调用
yield()，或者长时间运行，整个系统就会被“卡住”，其他任务无法执行。 - 没有优先级：所有任务都是平等的，按固定顺序执行。
- 功能简单：没有任务同步、通信、延时等高级功能。
任务间的通信与同步
在多任务环境中,任务之间需要交换数据和协调工作，这就需要同步和通信机制。
| 机制 | 描述 | C语言实现方式 |
|---|---|---|
| 互斥锁 | 保护共享资源，防止多个任务同时访问导致数据错乱。 | - Windows: CreateMutex, WaitForSingleObject, ReleaseMutex- Linux (Pthreads): pthread_mutex_t, pthread_mutex_lock, pthread_mutex_unlock- FreeRTOS: xSemaphoreCreateMutex, xSemaphoreTake, xSemaphoreGive |
| 信号量 | 用于控制对有限数量资源的访问，或者用于任务间的事件通知。 | - Windows: CreateSemaphore- Linux (Pthreads): sem_t, sem_wait, sem_post- FreeRTOS: xSemaphoreCreateBinary, xSemaphoreTake, xSemaphoreGive |
| 消息队列 | 允许任务之间发送和接收结构化的数据消息。 | - FreeRTOS: xQueueCreate, xQueueSend, xQueueReceive- Linux: msgget, msgsnd, msgrcv |
| 方法 | 适用场景 | 优点 | 缺点 |
|---|---|---|---|
| 操作系统 API | 桌面应用、服务器端开发 | 功能强大，稳定，社区支持好 | 依赖于特定操作系统，不适合资源受限的嵌入式设备 |
| 实时操作系统 | 嵌入式系统、工业控制、物联网 | 实时性强，功能专业（优先级、同步、通信），可靠 | 需要学习特定 RTOS 的 API，可能引入许可成本 |
| 自己实现 | 极度简单的单片机、教学演示 | 无需额外库，开销极小 | 功能极其有限，不健壮，难以维护复杂逻辑 |
如何选择？
- 如果你是在 Windows 或 Linux 上开发桌面程序，使用它们自带的线程库（
windows.h或pthread.h）。 - 如果你是在 嵌入式设备（如 STM32, ESP32）上开发，并且需要可靠的实时性，强烈建议使用一个成熟的 RTOS（如 FreeRTOS）。
- 如果你的项目非常简单,只是一个单片机在做一些周期性的、不复杂的操作，可以考虑自己实现一个简单的轮询调度器。
希望这个详细的解释能帮助你全面理解 C 语言中的 "tasking" 概念！
