Linux工作队列底层逻辑:异步机制与内核线程协同
- 2026-07-01 11:57:53
在 Linux 系统开发中，工作队列是实现异步任务处理、提升系统效率的核心机制，其底层逻辑直接决定了任务执行的稳定性与合理性。理解工作队列的底层逻辑，尤其是异步机制与内核线程的协同原理，是掌握内核任务调度、实现高效异步处理的关键，也是深入内核开发的重要基础。
本文将围绕工作队列的底层逻辑展开，重点拆解其异步机制的实现的核心，以及与内核线程的协同配合要点，清晰梳理二者的联动关系，帮助大家吃透工作队列的运行本质，规避使用中的认知误区，为后续深入学习、实操应用打下坚实基础，兼顾理论深度与理解难度，适配各类技术学习场景。
一、认识 Linux 工作队列
面试题写作模版
1.1 工作队列是什么？
工作队列是 Linux 内核提供的一种异步执行任务的机制，它利用内核线程来执行队列中的任务。这里面涉及到三个关键概念：工作（work）、工作队列（workqueue）和工作者线程（worker thread） 。
工作（work）：它代表一个需要被异步执行的任务单元。在内核中，工作由 work_struct 结构体来表示，这个结构体中最重要的成员是 func，它是一个函数指针，指向实际要执行的任务函数。比如你想让内核在某个合适的时候去更新文件系统的元数据，那么这个更新操作的函数就会被赋值给 func。同时，work_struct 还有其他成员，像 data 用于存储一些和任务相关的数据或状态信息，entry 则是用于将工作链接到工作队列链表中的节点。 工作队列（workqueue）：可以理解为一个存放工作的容器，用 workqueue_struct 结构体表示。它管理着一系列的工作，并且关联着负责执行这些工作的工作者线程。工作队列会将提交给它的工作按照一定的顺序组织起来，等待工作者线程来处理。例如，系统中可能有一个专门处理网络相关异步任务的工作队列，所有和网络数据接收后处理、网络连接状态更新等相关的工作都会被加入到这个队列中。 工作者线程（worker thread）：是实际执行工作的内核线程。每个工作者线程都属于某个特定的工作队列，它会不断地从对应的工作队列中取出工作并执行。这些线程在内核空间运行，并且可以被调度，就像普通的进程一样受到内核调度器的管理 。比如系统默认的 events 工作者线程，它会负责处理系统中很多一般性的异步任务。
三者的关系可以用一个形象的例子来说明：假如把 Linux 内核看作一个大型工厂，工作就像是一个个等待加工的零件订单，每个订单都有具体的加工要求（对应 work_struct 中的 func 函数）；工作队列则是存放这些订单的订单箱，不同类型的订单会被放入不同的订单箱（不同功能的工作队列）；而工作者线程就是工厂里的工人，他们从订单箱中取出订单（工作），按照订单要求进行加工（执行工作任务）。
1.2 为什么需要工作队列？
在 Linux 内核中，已经存在软中断（softirq）和 tasklet 等机制来处理异步任务，那为什么还需要工作队列呢？这主要是因为工作队列有着独特的优势和适用场景 。
首先，工作队列是在进程上下文执行的，这就赋予了它很多软中断和 tasklet 所不具备的能力。软中断和 tasklet 运行在中断上下文，中断上下文有严格的限制，比如不能睡眠（调用可能导致阻塞的函数，如 kmalloc(GFP_KERNEL)、mutex_lock、msleep 等），因为中断处理要求快速返回，不能长时间占用 CPU，否则会影响系统对其他中断的响应。
而工作队列在进程上下文执行，它可以睡眠 。这使得工作队列非常适合处理那些可能需要等待资源、进行 I/O 操作或者获取信号量的任务。例如，当一个设备驱动需要从磁盘读取大量数据时，这个读取操作可能会因为磁盘 I/O 的延迟而阻塞，如果用软中断或 tasklet 来处理，就会违反中断上下文的规则，而工作队列就可以很好地完成这个任务，因为它可以在等待磁盘 I/O 的过程中睡眠，让出 CPU 给其他任务。
其次，工作队列可以被调度。软中断和 tasklet 一旦被触发，会尽快执行，并且在执行过程中会一直占用 CPU（除非被更高优先级的中断打断），而工作队列中的任务就像普通进程一样，会受到内核调度器的管理 。这意味着工作队列中的任务可以根据系统的负载情况、任务的优先级等因素，合理地分配 CPU 时间片。比如，当系统中有多个工作队列任务同时等待执行时，调度器可以根据每个任务的优先级和当前系统的资源状况，决定先执行哪个任务，后执行哪个任务，从而提高系统整体的性能和响应能力。
从适用场景来看，工作队列适用于那些对时间要求不是特别紧急，但又需要异步执行的任务。比如，文件系统的一些后台操作，像定期的磁盘空间清理、文件索引更新等，这些操作虽然不需要立即完成，但如果放在主线程中同步执行，会影响系统的交互性能；再比如，一些设备驱动中的非关键初始化工作，也可以通过工作队列来异步完成，这样设备驱动在加载时就不会因为这些耗时操作而阻塞系统的启动过程。
二、工作队列核心原理
面试题写作模版
2.1 数据结构详解
工作队列的实现离不开各种数据结构的支持，不同的数据结构在工作队列中扮演着不同的角色，各有其优缺点。
链表：链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在工作队列中，链表常用于实现任务队列，因为它具有动态分配内存的特点，插入和删除操作非常高效，时间复杂度为 O (1) 。比如在一个简单的任务调度系统中，新任务的加入只需要修改链表尾节点的指针，将新任务节点链接到链表尾部即可。但链表也有其缺点，由于链表节点在内存中不是连续存储的，所以随机访问效率很低，时间复杂度为 O (n) ，当需要查找特定任务时，需要从头开始遍历链表，这在任务数量较多时会消耗大量时间。 数组：数组是一种连续存储的数据结构，通过索引可以直接访问元素，访问速度非常快，时间复杂度为 O (1) 。在工作队列中，如果任务数量相对固定，且对任务的访问以顺序访问为主，那么可以使用数组来实现任务队列。例如，在一个简单的定时任务系统中，任务按照时间顺序存储在数组中，系统可以根据索引快速获取下一个要执行的任务。然而，数组的大小在初始化时就确定了，如果任务数量动态变化，可能会导致数组溢出或空间浪费。而且数组的插入和删除操作效率较低，平均时间复杂度为 O (n) ，因为插入或删除元素时，需要移动其他元素来保持数组的连续性。 队列：队列是一种遵循先进先出（FIFO）原则的数据结构，它的操作主要有入队（enqueue）和出队（dequeue）。在工作队列中，队列是最基础的数据结构，它天然适合用于管理任务的执行顺序。例如，在一个 Web 服务器中，客户端的请求会被依次放入队列，服务器按照队列的顺序依次处理这些请求，保证了请求处理的公平性。队列的实现可以基于数组或链表，基于数组实现的队列称为顺序队列，基于链表实现的队列称为链式队列。顺序队列的优点是空间利用率高，但存在假溢出问题；链式队列的优点是不存在假溢出问题，且插入和删除操作效率高，但会额外占用指针空间。
在 Linux 内核正式实现中，工作队列并非简单使用基础数据结构，而是通过一套高度专业化的结构体体系完成任务管理、线程调度与资源分配，这套结构体是工作队列高效稳定运行的核心基石：
（1）work_struct：这是工作队列中最基本的结构体，就像是餐厅里的 “订单”，代表了一个需要被延迟执行的任务。它定义在 include/linux/workqueue.h 头文件中，其主要成员如下：
atomic_long_t data：这个成员通过原子操作，同时存储了工作的状态（比如是否正在执行、是否在队列中等）以及一个指向 pool_workqueue 的指针，是一个非常巧妙的 “多功能” 字段，用很少的内存空间实现了多种信息的存储。就好比订单上标注的 “已接单”“烹饪中”“待配送” 等状态，以及这个订单所属的厨师小组编号。 struct list_head entry：这是一个 Linux 内核标准双向链表结构，用于将这个工作挂载到某个队列（pending list）中，等待被处理。它就像订单上的挂钩，让订单能挂在任务板上排队。 work_func_t func：这是任务的核心，是一个函数指针，类型定义为 typedef void (*work_func_t)(struct work_struct *work)。当工作被执行时，就会调用这个函数，你编写的处理任务的具体代码就放在这里，比如 “烹饪牛排，七分熟，加黑胡椒汁” 这样的具体操作说明。
（2）workqueue_struct：这个结构体代表一个工作队列，也就是 “任务板”，定义在 kernel/workqueue.c 中，主要成员有：
struct list_head pwqs：一个工作队列可以关联到多个 pool_workqueue，这个链表头就是用来维护这些关联关系的。对于多 CPU（尤其是 NUMA 架构）的系统来说，这种设计非常重要，它就像是任务板上不同区域的标签，每个区域对应不同的厨师小组（pool_workqueue）。 struct list_head list：用于将当前工作队列链接到全局工作队列列表，方便内核统一管理所有的工作队列，就像把所有的任务板都挂在一个大的展示架上，方便查找和管理。 char name[WQ_NAME_LEN]：工作队列的名字，比如常见的 “events”“my_wq” 等。在 proc 文件系统中可以看到这些名字，通过名字可以方便地识别和管理不同的工作队列，就像给每个任务板贴上一个独特的标签，方便区分。
（3）worker_pool：这是一个隐藏的但至关重要的核心结构体，它不直接面向使用者，而是内核用于管理和调度工作线程的资源池，可以把它理解为 “厨师资源池” 或 “后厨本身”，在 kernel/workqueue_internal.h 和 kernel/workqueue.c 中定义，关键成员包括：
spinlock_t lock：用于保护这个资源池的锁，防止多线程并发访问时出现数据冲突，就像后厨的门禁，保证同一时间只有一个厨师能进入特定区域操作。 int cpu：该池绑定的 CPU 编号，如果是 -1 则表示未绑定，可以在任意 CPU 上执行任务。这对于优化 CPU 缓存命中率非常重要，比如某些对缓存亲和性要求高的任务，可以绑定到特定 CPU 上执行。 struct list_head worklist：这是真正存放待处理工作（work_struct）的链表，所有提交到该 worker_pool 的工作都通过其 entry 成员挂在这个链表上，就像后厨的真正任务板，上面挂满了等待处理的订单。 struct list_head idle_list：管理当前空闲的 “厨师”（worker），方便内核在有新任务时快速调度空闲的工作线程，就像记录着哪些厨师现在有空，可以随时接单。
（4）pool_workqueue：它是连接工作队列（workqueue_struct）和工作者池（worker_pool）的核心数据结构，作用类似于 “适配器”，负责将提交到工作队列的任务（work_struct）分发给具体的线程池执行。它的主要成员包括：
struct worker_pool *pool：指向关联的 worker_pool（线程池），明确任务要被分配到哪个厨师小组去处理。 struct workqueue_struct *wq：所属的工作队列，表明这个 “适配器” 是为哪个任务板服务的。 int nr_active：当前活跃的任务数，用于监控当前正在被处理的任务数量，就像统计正在做菜的订单数量。 int max_active：最大并发任务数限制，防止过多任务同时执行导致系统资源耗尽，比如规定一个厨师小组最多同时处理 5 个订单。
内核工作队列 —— 任务入队 / 出队实战示例：
#include <stdio.h>#include <stdlib.h>#include <string.h>// 定义任务节点结构体typedef struct TaskNode {char task_name[32]; // 任务名称 struct TaskNode *next; // 下一个节点} TaskNode;// 定义工作队列结构体typedef struct { TaskNode *front; // 队列头 TaskNode *rear; // 队列尾} WorkQueue;// 初始化工作队列voidInitWorkQueue(WorkQueue *queue){if (queue == NULL) return; queue->front = NULL; queue->rear = NULL;}// 任务入队intEnqueue(WorkQueue *queue, constchar *task_name){if (queue == NULL || task_name == NULL) { printf("参数无效\n");return -1; } TaskNode *new_node = (TaskNode *)malloc(sizeof(TaskNode));if (new_node == NULL) { printf("内存分配失败\n");return -1; }// 安全复制字符串 strncpy(new_node->task_name, task_name, sizeof(new_node->task_name) - 1); new_node->task_name[sizeof(new_node->task_name) - 1] = '\0'; new_node->next = NULL;if (queue->front == NULL) { queue->front = new_node; queue->rear = new_node; } else { queue->rear->next = new_node; queue->rear = new_node; }return0;}// 任务出队intDequeue(WorkQueue *queue, char *out_task, size_t buf_len){if (queue == NULL || out_task == NULL || buf_len == 0) { printf("参数无效\n");return -1; }if (queue->front == NULL) { printf("队列为空\n");return -1; } TaskNode *temp = queue->front; strncpy(out_task, temp->task_name, buf_len - 1); out_task[buf_len - 1] = '\0'; queue->front = queue->front->next; free(temp);if (queue->front == NULL) { queue->rear = NULL; }return0;}// 销毁队列，避免内存泄漏voidDestroyWorkQueue(WorkQueue *queue){if (queue == NULL) return; TaskNode *p = queue->front;while (p != NULL) { TaskNode *tmp = p; p = p->next; free(tmp); } queue->front = NULL; queue->rear = NULL;}intmain(){ WorkQueue queue;char task_buf[32]; InitWorkQueue(&queue);// 入队 Enqueue(&queue, "内核日志巡检任务"); Enqueue(&queue, "系统内存回收任务"); Enqueue(&queue, "外设中断响应任务");// 出队执行if (Dequeue(&queue, task_buf, sizeof(task_buf)) == 0) { printf("当前执行任务：%s\n", task_buf); }if (Dequeue(&queue, task_buf, sizeof(task_buf)) == 0) { printf("当前执行任务：%s\n", task_buf); }// 销毁队列 DestroyWorkQueue(&queue);return0;}2.2 任务管理机制
工作队列的任务管理机制是其核心功能之一，它负责对任务进行有效的组织和调度，确保任务能够按照预期的方式有序、高效执行，适配内核多线程并发运行场景。
（1）任务添加：任务添加是将新任务合规写入工作队列尾部、标记任务就绪状态的核心流程，内核级工作队列中，需同步做内存校验、队列容量阈值判断，避免内核内存溢出。可直接调用队列封装接口，快速完成内核态任务批量录入，适配高并发内核调度场景，全程贴合内核内存管控规范，无用户态内存交互损耗。
#include <stdio.h>#include <stdlib.h>#include <string.h>// 标准化任务节点、队列结构体typedef struct TaskNode {char task_name[32]; unsigned int task_flag; // 内核任务状态标记位 struct TaskNode *next;} TaskNode;typedef struct { TaskNode *front; TaskNode *rear; unsigned int queue_size; // 实时队列任务计数} KernelWorkQueue;// 批量添加内核调度任务voidBatchAddKernelTask(KernelWorkQueue *k_queue, constchar *task_arr[], int task_num){for (int i = 0; i < task_num; i++) { TaskNode *new_node = (TaskNode *)malloc(sizeof(TaskNode));if (new_node == NULL) continue; strcpy(new_node->task_name, task_arr[i]); new_node->task_flag = 0x01; // 标记为就绪可调度内核任务 new_node->next = NULL;if (k_queue->front == NULL) { k_queue->front = k_queue->rear = new_node; } else { k_queue->rear->next = new_node; k_queue->rear = new_node; } k_queue->queue_size++; printf("内核任务添加成功：%s\n", task_arr[i]); }}intmain(){ KernelWorkQueue k_queue = {NULL, NULL, 0};// 批量定义内核高频调度任务constchar *kernel_tasks[] = {"CPU 负载监测", "磁盘 IO 巡检", "网络链路保活", "内核缓存刷新"};// 批量写入工作队列 BatchAddKernelTask(&k_queue, kernel_tasks, 4); printf("当前队列待调度内核任务总数：%d\n", k_queue.queue_size);return0;}（2）任务删除：任务删除分为常规完工删除、异常失效强制删除两类场景，内核工作队列中，优先同步销毁任务占用内核内存，杜绝内存泄漏，同时实时更新队列计数，保障后续调度精准性。核心逻辑依托指针寻址、内存释放接口实现，适配内核无冗余高效运行要求，兼容批量清理、定点精准删除双重场景。
// 精准删除指定名称内核无效任务intDeleteSpecKernelTask(KernelWorkQueue *k_queue, constchar *target_task){if (k_queue->front == NULL) return -1; TaskNode *curr = k_queue->front; TaskNode *prev = NULL;// 遍历匹配目标无效任务while (curr != NULL && strcmp(curr->task_name, target_task) != 0) { prev = curr; curr = curr->next; }if (curr == NULL) return -2; // 未匹配到目标任务// 移除头部节点if (prev == NULL) { k_queue->front = curr->next; } else {// 移除中间/尾部节点 prev->next = curr->next; }// 同步修正尾指针if (curr == k_queue->rear) { k_queue->rear = prev; }// 释放内核内存，杜绝泄漏 free(curr); k_queue->queue_size--; printf("已清理无效内核任务：%s\n", target_task);return0;}intmain(){ KernelWorkQueue k_queue = {NULL, NULL, 0};constchar *kernel_tasks[] = {"CPU 负载监测", "磁盘 IO 巡检", "网络链路保活"}; BatchAddKernelTask(&k_queue, kernel_tasks, 3);// 定点删除异常失效任务 DeleteSpecKernelTask(&k_queue, "磁盘 IO 巡检"); printf("清理后剩余待调度任务数：%d\n", k_queue.queue_size);return0;}（3）优先级调度：优先级调度是内核工作队列核心调度能力，贴合操作系统分级响应需求，高优先级紧急内核任务优先抢占 CPU 资源，低优先级后台巡检任务延后调度。可通过自定义优先级权重字段、手动排序队列节点，轻量化实现内核专属优先级调度逻辑，无需依赖第三方组件，适配内核极简运行环境，规避高并发场景下低优先级任务饥饿问题。
// 带优先级的内核任务结构体typedef struct PriorityTask {char task_name[32];int priority; // 优先级：数值越大，调度优先级越高 struct PriorityTask *next;} PriorityTask;// 优先级工作队列结构体typedef struct { PriorityTask *head;} PriorityWorkQueue;// 初始化优先级队列voidInitPriorityQueue(PriorityWorkQueue *p_queue){ p_queue->head = NULL;}// 按优先级自动插入任务，实现有序调度voidPriorityEnqueue(PriorityWorkQueue *p_queue, constchar *task_name, int prio){ PriorityTask *new_task = (PriorityTask *)malloc(sizeof(PriorityTask));if (new_task == NULL) return; strcpy(new_task->task_name, task_name); new_task->priority = prio; new_task->next = NULL;// 头部插入：队列为空 / 新任务优先级最高if (p_queue->head == NULL || new_task->priority > p_queue->head->priority) { new_task->next = p_queue->head; p_queue->head = new_task;return; }// 遍历查找合适插入位置 PriorityTask *curr = p_queue->head;while (curr->next != NULL && curr->next->priority >= new_task->priority) { curr = curr->next; } new_task->next = curr->next; curr->next = new_task;}// 优先取出最高优先级任务执行voidExecHighPrioTask(PriorityWorkQueue *p_queue){if (p_queue->head == NULL) { printf("暂无优先级内核任务待执行\n");return; } PriorityTask *temp = p_queue->head; printf("执行高优先级内核任务：%s，优先级权重：%d\n", temp->task_name, temp->priority); p_queue->head = p_queue->head->next; free(temp);}intmain(){ PriorityWorkQueue p_queue; InitPriorityQueue(&p_queue);// 录入不同优先级内核任务 PriorityEnqueue(&p_queue, "紧急内核告警处置", 9); PriorityEnqueue(&p_queue, "常规内存定时巡检", 4); PriorityEnqueue(&p_queue, "实时硬件中断响应", 8);// 按优先级依次执行 ExecHighPrioTask(&p_queue); ExecHighPrioTask(&p_queue);return0;}以上优先级调度代码完美适配内核运行场景，自动按优先级排序任务，精准贴合操作系统内核线程分级调度需求，可直接嵌入底层调度模块使用，有效规避紧急任务响应延迟、低优先级任务长期阻塞等线上问题。在电商服务器内核调度、工业实时控制系统等场景中，可直接复用该逻辑优化工作队列调度效率。
2.3 异步执行机制
工作队列实现异步执行的过程，就像是一场精心编排的接力赛。当某个模块需要执行一个异步任务时，它会创建一个工作项（work_struct），并通过 INIT_WORK 宏来初始化这个工作项，将指向实际任务函数的指针赋值给 work_struct 的 func 成员，同时也可以根据需要设置 data 成员来传递相关的数据。
接着，使用 queue_work 函数（如果是延迟执行任务，则使用 queue_delayed_work 函数）将这个工作项添加到指定的工作队列中。queue_work 函数会把工作项插入到工作队列的链表中，并标记该工作项为待处理状态。此时，工作项就像是接力赛中被传递的接力棒，进入了等待处理的阶段。
在后台，与工作队列关联的工作者线程（worker thread）会不断地检查工作队列是否有任务。当发现工作队列中有工作项时，工作者线程就会从队列中取出工作项，并将其状态标记为正在处理。然后，工作者线程执行工作项中的任务函数（即 func 指向的函数）。在执行过程中，如果任务函数需要访问 work_struct 中携带的数据，就可以通过传入的 work_struct 指针来获取 data 成员的值。当任务函数执行完毕后，工作项的状态被标记为已完成，工作者线程又会继续去检查工作队列，寻找下一个待处理的工作项，如此循环往复。
从底层实现原理来看，工作队列的异步执行能力主要依托于三大核心机制支撑，分别是事件驱动模型、回调函数机制以及轻量协程异步适配方案，共同构成了 Linux 内核异步调度的完整技术体系。
（1）事件驱动模型：事件驱动模型是内核异步工作队列的核心底层依托，核心架构为常驻内核事件循环线程 + 统一事件监听队列。全程轮询监测硬件中断、网络报文、定时告警、任务超时等内核原生事件，捕获事件后自动封装为标准化任务推入工作队列，匹配空闲内核线程异步办结，全程无人工干预，贴合内核极简高效运行准则。Linux 内核原生异步调度模块，核心底层均采用轻量化事件驱动架构开发，适配全版本内核兼容需求。
#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <pthread.h>// 定义内核异步事件类型typedef enum { EVENT_NET_PACKET, // 网络数据包事件 EVENT_DISK_IO, // 磁盘读写事件 EVENT_SYS_TIMER // 系统定时内核事件} KernelEventType;// 内核事件结构体typedef struct { KernelEventType type;char event_msg[32];} KernelEvent;// 内核事件循环线程：常驻监听、异步分发任务void *KernelEventLoop(void *arg) {for (int i = 0; i < 3; i++) {// 异步捕获内核硬件事件 sleep(1); KernelEvent event;if (i == 0) { event.type = EVENT_NET_PACKET; strcpy(event.event_msg, "内核捕获网卡上行数据包"); } elseif (i == 1) { event.type = EVENT_DISK_IO; strcpy(event.event_msg, "内核磁盘批量读写完成回调"); } else { event.type = EVENT_SYS_TIMER; strcpy(event.event_msg, "内核定时内存回收触发"); }// 事件入队，交由工作队列异步调度线程处理 printf("事件循环捕获内核事件：%s，推入工作队列异步处理\n", event.event_msg); } pthread_exit(NULL);}// 内核工作队列异步处理线程void *WorkQueueAsyncDeal(void *arg) {// 被动接收事件队列推送任务，异步办结for (int i = 0; i < 3; i++) { sleep(1.2); // 后台异步处置耗时 printf("工作队列内核线程：异步办结对应内核联动任务\n"); } pthread_exit(NULL);}intmain(){ pthread_t event_thread, work_thread;// 启动内核事件循环监听线程 pthread_create(&event_thread, NULL, KernelEventLoop, NULL);// 启动工作队列异步处理专属内核线程 pthread_create(&work_thread, NULL, WorkQueueAsyncDeal, NULL);// 等待线程平稳运行结束 pthread_join(event_thread, NULL); pthread_join(work_thread, NULL); printf("内核异步事件+工作队列联动调度闭环完成\n");return0;}（2）回调函数：在事件触发与任务执行之间，回调函数是内核异步闭环的关键衔接载体，异步耗时任务发起后无需原地等待，仅提前绑定专属回调函数；待硬件 IO、外设交互等前置操作完成后，内核自动触发回调函数，批量收尾工作队列内后置联动任务，串联完整异步业务链路，规避线程无效阻塞。依托函数指针极简实现回调逻辑，无冗余封装，贴合内核低开销运行要求，是底层异步开发标配方案。
#include <stdio.h>#include <stdlib.h>#include <unistd.h>// 定义内核异步回调函数指针类型typedef void(*KernelAsyncCallback)(int task_result);// 内核发起异步耗时读写任务voidKernelStartAsyncIOTask(KernelAsyncCallback cb){ printf("内核：发起磁盘异步批量读写任务，不阻塞主线程，后台静默执行\n");// 硬件 IO 耗时操作 sleep(2);// 任务执行完毕，触发回调函数，收尾工作队列联动任务int ret_code = 0; // 0 代表 IO 任务执行成功 cb(ret_code);}// 自定义内核任务收尾回调函数voidIOTaskFinishCallback(int result){if (result == 0) { printf("回调触发：磁盘 IO 异步任务完成，工作队列联动执行缓存刷新、日志归档后置任务\n"); } else { printf("回调触发：磁盘 IO 任务异常，工作队列推送告警内核任务\n"); }}intmain(){// 绑定回调，发起异步内核任务 KernelStartAsyncIOTask(IOTaskFinishCallback);// 主线程同步并行处理其他核心工作，全程无阻塞 printf("内核主线程：同步推进 CPU 负载监测、线程调度核心工作，不受 IO 任务影响\n"); sleep(3);return0;}上述回调代码极简高效，精准复刻内核异步回调全流程，完美适配工作队列后置任务联动场景，有效规避多层嵌套阻塞问题，适配各类内核底层异步开发场景，兼容性拉满。内核开发中规范使用回调函数，提前规划回调链路层级，可彻底规避异步嵌套混乱问题，保障工作队列 + 内核线程协同链路稳定高效，无内核宕机隐患。
（3）轻量协程异步适配：在事件驱动与回调机制基础上，内核场景不适用重型多线程并发架构，依托轻量化协程思想，可在单条内核线程内拆分多路异步子任务，分时复用线程算力资源，无需频繁切换内核线程上下文，大幅降低系统调度开销。适配工作队列批量托管子任务，按需唤醒、按需挂起，完美适配低功耗嵌入式内核、高并发服务器内核双场景，是轻量化异步优化核心方案。
#include <stdio.h>#include <unistd.h>#include <setjmp.h>// 依托 setjmp/longjmp 实现极简轻量协程切换static jmp_buf env1, env2;// 协程 1：工作队列批量巡检子任务voidCoroutineWorkQueueCheck(){while (1) { printf("轻量协程：异步巡检工作队列待执行内核任务，核验任务合法性\n"); sleep(1);// 主动挂起，切换至另一协程 longjmp(env1, 1); }}// 协程 2：内核轻量化负载统计子任务voidCoroutineKernelLoadStat(){while (1) { printf("轻量协程：同步统计内核实时 CPU、内存负载数据\n"); sleep(1);// 主动挂起，切回队列巡检协程 longjmp(env2, 1); }}intmain(){ printf("内核启动单线程双协程异步调度，联动工作队列运行\n");// 初始化协程环境，分时切换异步执行if (setjmp(env2) == 0) CoroutineWorkQueueCheck();if (setjmp(env1) == 0) CoroutineKernelLoadStat();return0;}三、内核线程如何配合工作队列？
面试题写作模版
3.1 内核线程的创建与管理
在 Linux 内核中，工作队列相关的内核线程创建过程有着精细的机制。对于默认工作队列，内核会在系统初始化阶段为每个 CPU 核心创建对应的工作者线程。这些线程的名字通常以 kworker/开头，后面跟着 CPU 编号 。比如在一个 4 核系统中，会有 kworker/0:0、kworker/1:0、kworker/2:0、kworker/3:0 这样的线程 。内核通过 create_workqueue 函数（最终会调用__create_workqueue 等函数）来完成工作队列和内核线程的创建工作 。在创建过程中，会初始化 workqueue_struct 结构体和 cpu_workqueue_struct 结构体等相关数据结构
workqueue_struct 结构体用于描述工作队列，其中 cpu_wq 指向 cpu_workqueue_struct 结构体数组，每个数组项对应一个 CPU 核心的工作者线程相关信息 。cpu_workqueue_struct 结构体则包含了工作列表 worklist、等待队列 more_work、关联的工作队列指针 wq 以及线程指针 thread 等成员 。当创建自定义工作队列时，用户可以通过 create_workqueue 函数来创建，并可以通过参数指定工作线程是否绑定到特定的 CPU 核心上 。
如果是绑定到特定 CPU 的工作队列，线程名字会反映这一特性，例如 kworker/u2:0 表示这是一个绑定到 CPU 核心 0 的用户创建的工作队列的工作者线程 。在创建自定义工作队列的内核线程时，同样会初始化相关的数据结构，并且会根据用户的设置，将工作者线程与指定的 CPU 核心或者全局的工作队列管理机制进行关联 。
内核线程的销毁则相对简单，当工作队列不再需要时，通过 destroy_workqueue 函数来销毁工作队列，同时也会清理与该工作队列相关的内核线程 。在销毁过程中，会将内核线程从系统的调度队列中移除，释放线程占用的资源（如线程栈、任务描述符等），并将相关的数据结构（如 workqueue_struct、cpu_workqueue_struct 等）进行释放和清理 。
此外，内核还会动态地调整工作队列中内核线程的数量 。当系统负载较低，工作队列中的任务较少时，内核会减少工作者线程的数量，将一些空闲的线程停止或销毁，以节省系统资源 。而当系统负载增加，工作队列中的任务增多时，内核会根据需要创建新的工作者线程，以提高任务的处理速度 。
这种动态调整机制使得工作队列能够更好地适应系统的运行状态，提高系统整体的性能和资源利用率 。例如，在一个文件服务器系统中，当用户进行大量文件上传下载操作时，文件系统相关的工作队列任务增多，内核会适时增加工作者线程来处理这些任务；而在系统空闲时，这些工作者线程数量会减少，避免资源浪费 。
3.2 内核线程与工作队列协同工作流程
（1）任务提交阶段：当系统中的某个模块（如设备驱动、文件系统等）需要执行一个异步任务时，它会创建一个工作项（work_struct）。假设现在有一个网络设备驱动接收到一个数据包，需要对其进行解析和处理，驱动会创建一个工作项，将数据包处理函数作为工作项的任务函数（func），并设置一些相关的数据（如数据包的指针等）到 work_struct 的 data 成员中。
然后，通过 queue_work 函数将这个工作项添加到指定的工作队列中。此时，工作项会被插入到工作队列的链表中，并且工作队列会标记该工作项为待处理状态。例如，在一个多线程的 Web 服务器中，当网络模块接收到 HTTP 请求数据包时，会创建工作项并加入到网络工作队列。
// 任务提交：创建工作项 → 绑定处理函数 → 提交到工作队列struct work_struct net_rx_work;// 数据包处理任务函数voidnet_packet_process(struct work_struct *work){// 解析数据包、协议分析、上报协议栈 printk("网络数据包处理任务执行\n");}// 提交任务（驱动收到数据包时调用）voidnet_driver_rx_packet(void){// 初始化工作项 INIT_WORK(&net_rx_work, net_packet_process);// 提交到系统工作队列 queue_work(system_wq, &net_rx_work);}（2）任务获取阶段：与工作队列关联的内核线程（工作者线程）会不断地检查工作队列是否有任务。工作者线程在初始化完成后，会进入一个循环，在循环中它会首先检查工作队列的链表是否为空。如果为空，工作者线程会将自己设置为休眠状态（TASK_INTERRUPTIBLE），并把自己加入到等待队列中，等待有新的工作项被添加到工作队列时被唤醒。当工作队列中有新的工作项加入时，等待队列会发出信号，唤醒工作者线程。工作者线程被唤醒后，会将自己设置为运行状态（TASK_RUNNING），然后从工作队列的链表中取出第一个工作项。以文件系统的工作队列为例，负责文件元数据更新的工作者线程会不断检查工作队列，当有文件创建、修改等操作产生的元数据更新工作项时，线程会被唤醒并取出工作项。
// 工作者线程循环获取任务intworker_thread(void *arg){ WorkQueue *wq = (WorkQueue *)arg;while (1) {// 检查队列是否为空if (list_empty(&wq->worklist)) {// 无任务 → 进入休眠 set_current_state(TASK_INTERRUPTIBLE); schedule(); set_current_state(TASK_RUNNING);continue; }// 从队列取下第一个待处理工作项 struct work_struct *work = list_first_entry(&wq->worklist, struct work_struct, entry); list_del(&work->entry); }}（3）任务执行阶段：工作者线程取出工作项后，会执行工作项中的任务函数。在执行任务函数时，工作者线程可以访问 work_struct 中的 data 成员获取相关的数据。比如在上述网络数据包处理的例子中，工作者线程执行数据包处理函数时，会根据 data 中存储的数据包指针，对数据包进行解析、协议分析等操作。在任务执行过程中，如果任务函数需要睡眠（如等待某些资源、进行 I/O 操作等），由于工作者线程运行在进程上下文，它可以安全地进行睡眠操作，让出 CPU 给其他任务。例如，在处理一个需要从磁盘读取大量数据的文件操作任务时，工作者线程可以在等待磁盘 I/O 的过程中睡眠。
// 任务执行：工作者线程调用任务函数voidexecute_work(struct work_struct *work){// 执行任务处理函数 work->func(work);// 任务可安全睡眠（进程上下文） msleep(100); // 等待 IO、等待资源}（4）任务完成阶段：当任务函数执行完毕后，工作者线程会将工作项从工作队列的链表中移除，并标记该工作项为已完成状态。然后，工作者线程会再次检查工作队列是否还有其他待处理的工作项。如果有，它会继续取出并执行下一个工作项；如果没有，工作者线程会再次进入休眠状态，等待新的工作项到来。例如，在完成一个文件的元数据更新任务后，工作者线程会检查工作队列中是否还有其他文件的元数据更新任务，若没有则进入休眠。
// 任务完成：清理、标记完成、继续循环voidwork_completed(struct work_struct *work){// 标记任务完成 work->state = WORK_STATE_COMPLETED;// 继续处理下一个任务 goto again;}3.3 协同工作的优化策略
（1）线程池复用优化技术：内核线程频繁创建、销毁，会产生高额上下文切换开销、内存碎片损耗，长期运行易引发内核卡顿、局部宕机。线程池优化核心逻辑：系统初始化阶段批量创建固定数量常驻内核工作线程，长期绑定工作队列，任务峰值批量复用线程并行处置，低负载时段线程常驻休眠待命，全程不销毁、不重复创建，极致压缩内核调度开销，提升协同稳定性。基于 C 语言轻量化实现内核专属工作线程池，适配工作队列全量任务调度：
#include <stdio.h>#include <pthread.h>#include <unistd.h>#include <stdlib.h>#define THREAD_POOL_SIZE 4// 内核线程池固定常驻 4 条工作线程#define TASK_NUM 6// 待调度内核底层任务总数// 线程池任务结构体typedef struct {char task_name[32];} PoolTask;// 线程池全局资源PoolTask task_queue[TASK_NUM];int task_in = 0, task_out = 0;pthread_t pool_threads[THREAD_POOL_SIZE];pthread_mutex_t pool_lock;int pool_run_flag = 1;// 线程池常驻工作线程循环逻辑void *PoolKernelThread(void *arg) {int tid = *(int *)arg;while (pool_run_flag) { pthread_mutex_lock(&pool_lock);// 队列无任务则休眠待命if (task_in == task_out) { pthread_mutex_unlock(&pool_lock); usleep(50000);continue; }// 取出队列头部任务 PoolTask curr_task = task_queue[task_out]; task_out = (task_out + 1) % TASK_NUM; pthread_mutex_unlock(&pool_lock);// 线程异步执行内核任务 printf("内核线程池线程%d：办结工作队列任务【%s】\n", tid, curr_task.task_name); sleep(1); } pthread_exit(NULL);}// 向线程池工作队列投递任务voidPushTaskToPool(constchar *task_name){ pthread_mutex_lock(&pool_lock); strcpy(task_queue[task_in].task_name, task_name); task_in = (task_in + 1) % TASK_NUM; pthread_mutex_unlock(&pool_lock);}intmain(){int tid_arr[THREAD_POOL_SIZE] = {1,2,3,4};// 初始化线程池锁资源 pthread_mutex_init(&pool_lock, NULL);// 批量创建常驻内核线程池for (int i = 0; i < THREAD_POOL_SIZE; i++) { pthread_create(&pool_threads[i], NULL, PoolKernelThread, &tid_arr[i]); }// 批量投递内核运维任务至工作队列 PushTaskToPool("内核缓存刷新"); PushTaskToPool("网卡链路巡检"); PushTaskToPool("内存碎片整理"); PushTaskToPool("外设中断复位"); PushTaskToPool("系统日志归集"); PushTaskToPool("CPU 负载校准");// 等待任务全部执行完毕 sleep(4);// 安全销毁线程池资源 pool_run_flag = 0;for (int i = 0; i < THREAD_POOL_SIZE; i++) { pthread_join(pool_threads[i], NULL); } pthread_mutex_destroy(&pool_lock);return0;}线程池核心优化价值三重兜底：一是彻底规避线程频繁启停内存损耗，内核长期运行零碎片堆积；二是精准管控最大并发线程数，杜绝线程超限抢占内核资源引发宕机；三是统一管控全量队列任务，支持优先级、超时熔断精细化管控，全方位强化协同运行可靠性。
（2）智能负载均衡优化：多内核线程联动工作队列规模化调度场景中，极易出现负载失衡问题：部分线程积压海量 IO 运维任务满载过载卡顿，部分线程闲置空转浪费算力资源。智能负载均衡核心优化逻辑：实时采集每条内核线程 CPU 占用率、任务积压数量、运行时延三大核心指标，动态调度工作队列任务流向，自动将积压任务分流至空闲线程，全域拉平负载，最大化盘活整机内核算力。
主流适配内核轻量化均衡算法均基于 C 语言原生开发：轮询均分适配平稳低负载场景，任务逐一分发、均衡无偏差；加权轮询差异化适配，高算力内核线程分配更多复杂运维任务，低算力线程承接轻量化巡检任务；最少负载优先抢占，实时匹配空闲最优线程，峰值高并发场景适配性最强；哈希定向分发，同源硬件绑定专属线程，保障硬件任务调度连贯性，规避跨线程交互损耗。
四、工作队列实战案例
面试题写作模版
4.1 环境准备工作
在开始工作队列的实操之前，我们需要准备好相应的环境。这里以 Ubuntu 20.04 系统为例，其他 Linux 发行版的操作步骤类似 。
（1）系统环境：确保你已经安装了 Linux 系统，如 Ubuntu、CentOS 等。如果是在虚拟机中安装，建议分配至少 2GB 内存和 20GB 磁盘空间，以保证系统运行的流畅性 。例如，在 VMware Workstation 中创建虚拟机时，选择 “典型” 配置，加载 Ubuntu 镜像，设置好虚拟机名称、存储位置，然后分配 2GB 内存和 20GB 磁盘空间 。
（2）开发工具：安装必要的开发工具，如 GCC 编译器和 Make 工具。在 Ubuntu 系统中，可以通过以下命令安装：
sudo apt updatesudo apt install build-essential这两条命令首先更新软件源列表，然后安装 GCC、Make 等开发工具，安装过程中可能需要输入系统密码 。
（3）内核头文件：为了能够编译与内核相关的代码，需要安装内核头文件。在 Ubuntu 系统中，可以使用以下命令安装对应版本的内核头文件（请根据实际内核版本替换$(uname -r)）：
sudo apt install linux-headers-$(uname -r)这条命令会自动安装与当前系统内核版本匹配的头文件，确保在编译内核模块时能够找到所需的内核定义和接口 。
4.2 手把手写代码：完整实现步骤
（1）定义工作任务：首先，我们要定义一个工作任务。在 Linux 内核中，可以使用 DECLARE_WORK 或 INIT_WORK 宏来定义一个 work_struct 结构体，它代表一个工作任务 。DECLARE_WORK 宏用于在编译时静态地定义并初始化一个工作任务，而 INIT_WORK 宏用于在运行时动态地初始化一个已定义的工作任务 。下面是一个使用 DECLARE_WORK 宏定义工作任务的示例：
#include <linux/module.h>#include <linux/kernel.h>#include <linux/workqueue.h>// 定义工作处理函数voidmy_work_func(struct work_struct *work){ printk(KERN_INFO "This is my work function. Executing task...\n");// 这里添加具体的任务代码，比如数据处理、文件操作等}// 使用 DECLARE_WORK 宏定义工作任务DECLARE_WORK(my_work, my_work_func);在这个示例中，my_work_func 是工作任务的处理函数，它接受一个 struct work_struct *work 类型的参数，这个参数指向当前正在处理的工作任务结构体 。在函数内部，我们打印了一条信息表示任务正在执行，实际应用中可以在这里添加具体的任务代码，比如对数据进行处理、进行文件读写操作等 。DECLARE_WORK(my_work, my_work_func)宏定义了一个名为 my_work 的工作任务，它关联到 my_work_func 处理函数 。
（2）创建工作队列：接下来，我们要创建一个工作队列。可以使用 create_workqueue 宏来创建一个工作队列，它会为系统中的每个 CPU 都创建一个内核线程来处理队列中的工作 。如果希望所有工作都在同一个内核线程中顺序执行，可以使用 create_singlethread_workqueue 宏创建一个单线程工作队列 。下面是使用 create_workqueue 宏创建工作队列的示例：
struct workqueue_struct *my_wq;staticint __init my_module_init(void){// 创建工作队列 my_wq = create_workqueue("my_wq");if (!my_wq) { printk(KERN_ERR "Failed to create workqueue\n");return -ENOMEM; }// 其他初始化代码return0;}在上述代码中，create_workqueue("my_wq")创建了一个名为 “my_wq” 的工作队列，并将返回的工作队列结构体指针赋值给 my_wq 。如果创建失败，my_wq 将为 NULL，此时打印错误信息并返回错误码-ENOMEM 表示内存分配失败 。
（3）调度工作任务：创建好工作任务和工作队列后，就可以将工作任务调度到工作队列中执行 。使用 schedule_work 函数可以将工作任务提交到系统默认的工作队列中立即执行；如果需要延迟执行，可以使用 schedule_delayed_work 函数，它可以指定延迟的时间（以时钟节拍为单位，1 个时钟节拍通常为 1/HZ 秒，HZ 的值可以通过/boot/config-$(uname -r)文件查看，一般为 100、250、1000 等） 。如果要将工作任务调度到自定义的工作队列中，可以使用 queue_work 或 queue_delayed_work 函数 。以下是将工作任务调度到自定义工作队列中立即执行的示例：
staticint __init my_module_init(void){// 创建工作队列 my_wq = create_workqueue("my_wq");if (!my_wq) { printk(KERN_ERR "Failed to create workqueue\n");return -ENOMEM; }// 将工作任务调度到自定义工作队列int ret = queue_work(my_wq, &my_work);if (!ret) { printk(KERN_ERR "Failed to queue work\n"); }return0;}在这段代码中，queue_work(my_wq, &my_work)将 my_work 工作任务调度到 my_wq 工作队列中执行 。queue_work 函数返回一个布尔值，表示工作任务是否成功入队，如果返回值为 0，则表示入队失败，此时打印错误信息 。
（4）处理任务结果：在工作任务的处理函数中，可以根据实际需求处理任务执行的结果 。如果任务执行过程中产生了一些数据，可以将这些数据传递给其他模块进行进一步处理 。例如，在处理函数中可以将处理结果存储在全局变量中，然后其他模块通过访问该全局变量来获取结果；也可以通过内核消息队列、共享内存等方式与其他模块进行数据交互 。下面是一个简单的示例，在处理函数中打印任务执行结果，并通过全局变量传递一个简单的状态值：
#include <linux/module.h>#include <linux/kernel.h>#include <linux/workqueue.h>// 定义一个全局变量用于存储任务执行状态int task_status = 0;// 定义工作处理函数voidmy_work_func(struct work_struct *work){// 任务执行，这里简单地设置任务状态为 1 表示成功 task_status = 1; printk(KERN_INFO "Task executed successfully. Task status: %d\n", task_status);// 其他任务处理代码}// 使用 DECLARE_WORK 宏定义工作任务DECLARE_WORK(my_work, my_work_func);struct workqueue_struct *my_wq;staticint __init my_module_init(void){// 创建工作队列 my_wq = create_workqueue("my_wq");if (!my_wq) { printk(KERN_ERR "Failed to create workqueue\n");return -ENOMEM; }// 将工作任务调度到自定义工作队列int ret = queue_work(my_wq, &my_work);if (!ret) { printk(KERN_ERR "Failed to queue work\n"); }return0;}staticvoid __exit my_module_exit(void){// 取消工作任务（如果需要） cancel_work_sync(&my_work);// 销毁工作队列 destroy_workqueue(my_wq);}module_init(my_module_init);module_exit(my_module_exit);MODULE_LICENSE("GPL");在这个完整的示例中，my_work_func 函数中设置了 task_status 变量表示任务执行状态，并打印了任务执行结果和状态值 。在模块初始化函数 my_module_init 中，创建工作队列并将工作任务调度到队列中 。在模块退出函数 my_module_exit 中，使用 cancel_work_sync 函数取消工作任务（确保任务不再执行），然后使用 destroy_workqueue 函数销毁工作队列，释放相关资源 。
4.3 结果分析与调试
（1）运行结果观察：完成代码编写后，将其编译成内核模块（.ko 文件） 。在终端中进入代码所在目录，执行以下命令进行编译：
make -C /lib/modules/$(uname -r)/build M=$(pwd) modules这条命令利用 Make 工具，指定内核源代码目录（/lib/modules/$(uname -r)/build）和当前模块代码目录（M=$(pwd)）进行编译 。编译完成后，会生成.ko 文件 。然后，加载内核模块：
sudo insmod your_module.ko将 your_module.ko 替换为实际生成的模块文件名 。加载模块后，可以通过查看内核日志来观察任务执行结果 。在 Ubuntu 系统中，可以使用以下命令查看内核日志：
dmesg | grep "This is my work function"这条命令会从内核日志中过滤出包含 “This is my work function” 的日志行，也就是我们在工作任务处理函数中打印的信息，从而确认任务是否按预期执行 。同时，还可以观察任务执行的时间、CPU 等信息 。例如，可以在工作任务处理函数的开头和结尾分别打印时间戳，计算任务执行的时间：
#include <linux/module.h>#include <linux/kernel.h>#include <linux/workqueue.h>#include <linux/time.h>// 定义工作处理函数voidmy_work_func(struct work_struct *work){ struct timespec start, end; getnstimeofday(&start); printk(KERN_INFO "This is my work function. Executing task...\n");// 这里添加具体的任务代码，比如数据处理、文件操作等 getnstimeofday(&end); unsigned long duration = (end.tv_sec - start.tv_sec) * 1000000000 + (end.tv_nsec - start.tv_nsec); printk(KERN_INFO "Task execution time: %lu nanoseconds\n", duration);}// 使用 DECLARE_WORK 宏定义工作任务DECLARE_WORK(my_work, my_work_func);// 其他代码...在上述代码中，使用 getnstimeofday 函数获取任务开始和结束的时间戳，然后计算任务执行的时间差并打印出来 。对于任务执行的 CPU 信息，可以通过 task_struct 结构体中的 cpu 字段获取当前执行任务的 CPU 编号 。在工作任务处理函数中，可以通过 current 指针获取当前任务的 task_struct 结构体，进而获取 CPU 编号：
#include <linux/module.h>#include <linux/kernel.h>#include <linux/workqueue.h>#include <linux/sched.h>// 定义工作处理函数voidmy_work_func(struct work_struct *work){int cpu = smp_processor_id(); printk(KERN_INFO "This task is being executed on CPU %d\n", cpu);// 其他任务处理代码}// 使用 DECLARE_WORK 宏定义工作任务DECLARE_WORK(my_work, my_work_func);// 其他代码...在这段代码中，使用 smp_processor_id 函数获取当前执行任务的 CPU 编号，并打印出来 。
（2）常见问题与解决：在工作队列实操过程中，可能会遇到一些常见问题：
①任务不执行：如果任务没有按预期执行，首先检查工作任务是否正确调度到工作队列中 。可以在调度函数（如 queue_work、schedule_work 等）调用后添加打印语句，确认调度是否成功 。例如：
int ret = queue_work(my_wq, &my_work);if (!ret) { printk(KERN_ERR "Failed to queue work\n");} else { printk(KERN_INFO "Work queued successfully\n");}同时，检查工作任务处理函数是否有语法错误或逻辑错误 。可以在处理函数开头添加简单的打印语句，如 printk(KERN_INFO "Entering work function")，确认处理函数是否被调用 。如果处理函数中存在可能导致阻塞或睡眠的操作，确保这些操作在进程上下文是允许的 。
②执行顺序错误：如果任务执行顺序不符合预期，特别是在多线程或多任务环境下，要考虑是否存在竞态条件 。例如，多个工作任务同时访问和修改共享资源时，可能会导致数据不一致或执行顺序混乱 。可以使用自旋锁（spinlock_t）、互斥锁（mutex）等同步机制来保护共享资源 。以下是使用互斥锁的示例：
#include <linux/module.h>#include <linux/kernel.h>#include <linux/workqueue.h>#include <linux/mutex.h>// 定义共享资源int shared_variable = 0;// 定义互斥锁struct mutex shared_mutex;// 定义工作处理函数voidmy_work_func(struct work_struct *work){// 加锁 mutex_lock(&shared_mutex); shared_variable++; printk(KERN_INFO "Shared variable updated: %d\n", shared_variable);// 解锁 mutex_unlock(&shared_mutex);}// 使用 DECLARE_WORK 宏定义工作任务DECLARE_WORK(my_work, my_work_func);// 其他代码...staticint __init my_module_init(void){// 初始化互斥锁 mutex_init(&shared_mutex);// 其他初始化代码return0;}staticvoid __exit my_module_exit(void){// 销毁互斥锁 mutex_destroy(&shared_mutex);// 其他销毁代码}在这个示例中，定义了一个共享变量 shared_variable 和一个互斥锁 shared_mutex 。在工作任务处理函数中，使用 mutex_lock 函数加锁，确保在修改共享变量时不会被其他任务干扰，操作完成后使用 mutex_unlock 函数解锁 。在模块初始化函数中初始化互斥锁，在模块退出函数中销毁互斥锁 。
③内存泄漏：如果在工作任务处理函数中分配了内存（如使用 kmalloc 函数），一定要记得在适当的位置释放内存（使用 kfree 函数），否则会导致内存泄漏 。例如：
#include <linux/module.h>#include <linux/kernel.h>#include <linux/workqueue.h>#include <linux/slab.h>// 定义工作处理函数voidmy_work_func(struct work_struct *work){char *buffer = kmalloc(1024, GFP_KERNEL);if (buffer) {// 使用 buffer 进行数据处理//...// 释放内存 kfree(buffer); }}// 使用 DECLARE_WORK 宏定义工作任务DECLARE_WORK(my_work, my_work_func);// 其他代码...在这个示例中，使用 kmalloc 函数分配了 1024 字节的内存，在使用完后，通过 kfree 函数释放内存，避免内存泄漏 。
end
如果这篇文章对你有所启发，欢迎点赞、在看，转发三连。星标⭐账号，还可以第一时间收到推送，感谢你的收看，我们下期再见～
往期干货推荐
