任务创建与管理：TCB结构、栈分配与创建方式

任务管理是RTOS的核心。说白了，任务就是一个无限循环的C函数，但操作系统得知道这个函数跑在哪儿、状态如何、优先级多少。这些信息全存在一个结构体里——任务控制块（TCB）。

我刚开始接触RTOS时，总觉得TCB就是个简单的结构体，后来在项目里踩过坑才明白，TCB的设计直接决定了系统的稳定性和可调试性。今天咱们就把它拆开揉碎了讲。

任务控制块（TCB）结构

每个任务在系统中都有一个对应的TCB。它就像任务的身份证，记录了任务的所有关键信息。一个典型的TCB长这样：

typedef struct tcb {
    uint32_t    *stack_ptr;      // 当前栈指针（SP）
    uint32_t    *stack_base;     // 栈底地址
    uint32_t    stack_size;      // 栈大小（单位：字）
    
    uint8_t     priority;        // 任务优先级
    uint8_t     state;           // 任务状态：就绪/阻塞/挂起/运行
    uint8_t     task_id;         // 任务ID
    
    void        (*entry)(void*); // 任务入口函数
    void        *arg;            // 入口函数参数
    
    struct tcb  *next;           // 链表指针（用于就绪队列等）
    
    uint32_t    delay_ticks;     // 延时计数（用于阻塞延时）
    uint32_t    suspend_count;   // 挂起计数
    
    #ifdef ENABLE_STACK_CHECK
    uint32_t    stack_high_mark; // 栈使用峰值记录
    #endif
    
    #ifdef ENABLE_TASK_NAME
    char        name[16];        // 任务名称（调试用）
    #endif
} TCB_t;

这里我特别想强调几个关键字段：

• stack_ptr：这是CPU当前使用的栈指针。任务切换时，我们保存当前CPU寄存器到这个指针指向的位置，然后加载下一个任务的stack_ptr。嗯，上下文切换的核心就在这一行。
• state：任务状态机。我见过不少新手把状态搞混，导致任务调度异常。记住：一个任务同一时刻只能处于一种状态。
• next：链表指针。RTOS里各种队列（就绪队列、阻塞队列、挂起队列）都是用链表串起来的。TCB就是链表节点。

任务栈分配

每个任务都需要独立的栈空间。为什么？因为任务切换时，CPU寄存器、局部变量、函数调用返回地址都保存在栈里。如果两个任务共用栈，一切换就全乱了。

栈分配有两种方式：

静态栈分配

在编译时就确定栈空间，通常用全局数组：

// 静态分配栈空间
#define TASK1_STACK_SIZE   256
#define TASK2_STACK_SIZE   512

static uint32_t task1_stack[TASK1_STACK_SIZE];
static uint32_t task2_stack[TASK2_STACK_SIZE];

这种方式简单直接，栈地址在链接时就已经固定。适合任务数量固定、栈需求明确的场景。

动态栈分配

运行时从堆中分配：

// 动态分配栈空间
uint32_t *stack = (uint32_t*)malloc(stack_size * sizeof(uint32_t));
if (stack == NULL) {
    // 处理分配失败
    return ERROR_OUT_OF_MEMORY;
}

动态分配灵活，但有个大坑——碎片化。我曾经在一个长期运行的设备上，频繁创建删除任务，结果堆内存碎成渣，后来任务创建总是失败。从那以后，我对动态分配就格外谨慎。

栈大小估算

栈开多大？开小了栈溢出，开大了浪费RAM。我一般这样估算：

因素	典型占用	说明
任务切换上下文	16-32 字	CPU寄存器保存（取决于架构）
函数调用嵌套	每层 4-8 字	返回地址 + 局部变量
中断嵌套	16-64 字	中断服务程序上下文
任务局部变量	视情况而定	最大局部数组/结构体
printf/日志	64-128 字	格式化缓冲区

一个经验公式：任务栈大小 = 上下文保存 + 最大调用深度 × 每层开销 + 最大局部变量 + 安全余量（20%）。

动态创建 vs 静态创建

两种方式各有适用场景，我整理了一个对比表：

对比维度	静态创建	动态创建
TCB存储位置	全局/静态区	堆区
栈存储位置	全局/静态区	堆区
创建时机	编译时确定	运行时决定
灵活性	低（数量固定）	高（可按需创建）
内存碎片风险	无	有
确定性	高（适合实时系统）	低（分配时间不确定）
调试难度	低（地址固定）	中（需跟踪堆状态）

静态创建示例

// 静态TCB和栈
static TCB_t task1_tcb;
static uint32_t task1_stack[256];

void task1_entry(void *arg) {
    while(1) {
        // 任务逻辑
    }
}

void os_init(void) {
    // 初始化TCB
    task1_tcb.stack_base  = task1_stack;
    task1_tcb.stack_size  = 256;
    task1_tcb.priority    = 3;
    task1_tcb.entry       = task1_entry;
    task1_tcb.arg         = NULL;
    task1_tcb.state       = STATE_READY;
    
    // 初始化栈（填充初始上下文）
    task_stack_init(&task1_tcb);
    
    // 加入就绪队列
    ready_queue_add(&task1_tcb);
}

动态创建示例

// 动态创建任务API
TCB_t* os_task_create(void (*entry)(void*), 
                      void *arg,
                      uint8_t priority,
                      uint32_t stack_size) {
    // 分配TCB
    TCB_t *tcb = (TCB_t*)malloc(sizeof(TCB_t));
    if (tcb == NULL) return NULL;
    
    // 分配栈
    tcb->stack_base = (uint32_t*)malloc(stack_size * sizeof(uint32_t));
    if (tcb->stack_base == NULL) {
        free(tcb);
        return NULL;
    }
    
    // 初始化
    tcb->stack_size  = stack_size;
    tcb->priority    = priority;
    tcb->entry       = entry;
    tcb->arg         = arg;
    tcb->state       = STATE_READY;
    
    task_stack_init(tcb);
    ready_queue_add(tcb);
    
    return tcb;
}

// 使用
TCB_t *sensor_task = os_task_create(sensor_entry, NULL, 5, 256);

任务创建流程总览

不管静态还是动态，任务创建的底层逻辑是一样的。我画了张图，把整个流程串起来：

你看，流程其实不复杂。但每个步骤都有细节要注意：

• 步骤1：静态创建时，TCB和栈的地址在链接脚本里就定好了。动态创建时，要检查malloc返回值，别直接拿来用。
• 步骤3：栈初始化是重点。我们需要在栈里预填好初始上下文，包括CPU寄存器初始值、返回地址（指向任务入口函数）、以及一些调试标记。这样第一次切换到这个任务时，CPU直接从栈里恢复上下文，就能跑起来了。
• 步骤5：加入就绪队列时，如果是优先级调度，要按优先级插入到正确位置。我见过一个bug，新任务总是插到队尾，导致高优先级任务得不到及时调度。