在Linux内核中，kthread（内核线程）用于创建运行在内核空间的后台线程，常用于驱动开发中执行异步任务（如轮询设备状态、数据处理等）。以下是详细的使用示例和实现逻辑分析：

---

一、kthread核心机制

1. 关键函数

• kthread_create / kthread_run
  创建内核线程，区别在于：

  • kthread_create: 创建线程但不立即启动，需手动调用wake_up_process。

  • kthread_run: 创建并直接启动线程（内部调用wake_up_process）。

  
  struct task_struct *kthread_create(int (*threadfn)(void *data), 
                                    void *data, 
                                    const char namefmt[], ...);
  struct task_struct *kthread_run(int (*threadfn)(void *data), 
                                 void *data, 
                                 const char namefmt[], ...);

• kthread_stop
  停止线程，需线程函数中调用kthread_should_stop响应终止请求。

  int kthread_stop(struct task_struct *k);

• kthread_should_stop
  检查线程是否收到停止信号，通常用于循环退出条件。

---

二、使用示例（完整驱动模块）

场景

创建一个周期性打印日志的内核线程，模块加载时启动线程，卸载时停止线程。

代码实现

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/kthread.h>
#include <linux/delay.h>

static struct task_struct *kthread_task; // 线程指针
static int thread_interval_ms = 1000;    // 线程执行间隔（毫秒）

// 线程函数定义
static int kthread_worker(void *data) {
    while (!kthread_should_stop()) {    // 检查停止信号
        printk(KERN_INFO "kthread: Running, interval=%d ms\n", thread_interval_ms);
        msleep(thread_interval_ms);     // 休眠（非精确延时）
    }
    printk(KERN_INFO "kthread: Stopped\n");
    return 0;
}

// 模块初始化
static int __init kthread_example_init(void) {
    // 创建并启动线程
    kthread_task = kthread_run(kthread_worker, NULL, "my_kthread");
    if (IS_ERR(kthread_task)) {
        printk(KERN_ERR "Failed to create kthread\n");
        return PTR_ERR(kthread_task);
    }
    printk(KERN_INFO "kthread: Created\n");
    return 0;
}

// 模块卸载
static void __exit kthread_example_exit(void) {
    if (kthread_task) {
        kthread_stop(kthread_task); // 发送停止信号
        printk(KERN_INFO "kthread: Stopping\n");
    }
}

module_init(kthread_example_init);
module_exit(kthread_example_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");

---

三、关键实现逻辑

1. 线程生命周期管理

• 启动线程
  使用kthread_run创建并启动线程，第三个参数为线程名称（/proc/<pid>/comm中可见）。

• 停止线程
  调用kthread_stop会设置线程的停止标志，线程函数需通过kthread_should_stop()检测并退出循环。

2. 线程函数设计

• 循环条件
  必须包含while (!kthread_should_stop())，否则kthread_stop可能阻塞。

• 休眠替代方案
  避免使用ssleep或msleep长时间阻塞，若需高精度定时，可结合hrtimer（见前文）。

3. 错误处理

• 检查线程创建结果
  kthread_run返回的task_struct需用IS_ERR检查，防止空指针或错误码。

---

四、进阶用法

1. 向线程传递参数

通过data参数传递自定义数据结构：

struct thread_data {
    int interval;
    bool enable_debug;
};

static int kthread_worker(void *data) {
    struct thread_data *tdata = (struct thread_data *)data;
    while (!kthread_should_stop()) {
        if (tdata->enable_debug)
            printk(KERN_DEBUG "kthread: Debug mode\n");
        msleep(tdata->interval);
    }
    return 0;
}

// 初始化时传递数据
struct thread_data tdata = {
    .interval = 2000,
    .enable_debug = true
};
kthread_task = kthread_run(kthread_worker, &tdata, "my_kthread");

2. 线程优先级与调度

通过sched_setscheduler调整线程优先级（需包含<linux/sched.h>）：

struct sched_param param = { .sched_priority = 50 }; // 实时优先级
sched_setscheduler(kthread_task, SCHED_FIFO, &param);

3. 同步与互斥

使用内核锁（如自旋锁、互斥锁）保护共享资源：

static DEFINE_SPINLOCK(data_lock);
unsigned int shared_counter = 0;

static int kthread_worker(void *data) {
    while (!kthread_should_stop()) {
        spin_lock(&data_lock);
        shared_counter++;
        spin_unlock(&data_lock);
        msleep(1000);
    }
    return 0;
}

---

五、注意事项

1. 避免阻塞操作
   内核线程不应长时间阻塞（如等待用户空间事件），否则可能导致内核软锁定（soft lockup）。

2. 资源释放
   确保模块卸载时调用kthread_stop，否则线程可能继续访问已释放的资源。

3. 调试信息
   使用dmesg查看内核日志，或通过/sys/kernel/debug/tracing跟踪线程行为。

---

六、完整编译与测试

1. Makefile

makefile

obj-m += kthread_example.o

all:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

2. 操作步骤

# 编译模块
make

# 加载模块
sudo insmod kthread_example.ko

# 查看内核日志
dmesg | tail

# 卸载模块
sudo rmmod kthread_example

---

通过上述示例和逻辑，可以在Linux驱动中高效管理内核线程，实现异步任务处理。结合同步机制和参数传递，可扩展至复杂场景（如多线程协作、实时数据处理）。