内核线程是直接由内核本身启动的进程。内核线程实际上是将内核函数委托给独立的进程，它与内核中的其他进程”并行”执行。内核线程经常被称之为内核守护进程。内核线程是被调度的实体，它被加入到某种数据结构中，调度程序根据实际情况进行线程的调度。
内核线程与用户态线程的作用类似，通常用于执行某些周期性的计算任务，或者在后台执行需要大量计算的任务。
本文主要介绍一下内核线程操作相关的API的使用，以及内核线程的实现基本原理，更深入的内容在后续文章中介绍。
内核线程操作函数
内核线程操作涉及的函数（API）主要是创建、调度和停止等函数。操作起来也是比较简单的。下面分别介绍一下这些接口的定义。
创建线程
创建线程的函数为kthread_create，如下是函数的原型，该函数实际上是函数kthread_create_on_node的一个宏定义。后者则是在某个CPU上创建一个线程。该函数的前两个参数分别是线程主函数指针和函数的参数，而后面的参数通过变参数的方式为线程命名。
#define kthread_create(threadfn, data, namefmt, arg...) \
kthread_create_on_node(threadfn, data, NUMA_NO_NODE, namefmt, ##arg)
唤醒线程
通过该函数创建的线程处于非运行状态，需要调用wake_up_process函数将其唤醒后才可以在CPU上运行。
int wake_up_process(struct task_struct *p)
创建并运行线程
在内核的API中有另外一个接口可以直接创建一个处于运行状态的线程，其定义如下。这里其实就是调用了上文描述的两个函数。
#define kthread_run(threadfn, data, namefmt, ...) \
({ \
struct task_struct *__k \
= kthread_create(threadfn, data, namefmt, ## __VA_ARGS__); \
if (!IS_ERR(__k)) \
wake_up_process(__k); \
__k; \
})
停止线程
线程也可以被停止，此时主函数将会退出，当然需要主函数的实现考虑该问题。如下是停止线程的函数接口。
int kthread_stop(struct task_struct *k)
线程的调度
内核线程创建完成后将一直运行下去，除非遇到了阻塞事件或者自己将自己调度出去。通过下面函数，线程可以将自己调度出去。调度出去的含义就是将CPU让给其它线程。
asmlinkage __visible void __sched schedule(void)
简单内核线程使用
前面介绍了内核线程基本原理及相关的API，下面我们将开发一个内核线程的基本实例。
这个实例是在一个内核模块中启动一个内核线程。内核线程的作用很简单，就是定时的向系统日志中输出一个字符串。本例的目的主要是介绍如何创建、使用和销毁一个内核线程。
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <linux/socket.h>
#include <net/sock.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#define BUF_SIZE 1024
struct task_struct *main_task;
/* 这个函数用于将内核线程置于休眠状态，也就是将其调度出
* 队列。*/
static inline void sleep(unsigned sec)
{
__set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(sec * HZ);
}
/* 线程函数， 这个是线程执行的主体 */
static int multhread_server(void *data)
{
int index = 0;
/* 在线程没有被停止的情况下，循环向系统日志输出
* 内容， 完成后休眠1秒。*/
while (!kthread_should_stop()) {
printk(KERN_NOTICE "thread run %d\n", index);
index ++;
sleep(1);
}
return 0;
}
static int multhread_init(void)
{
ssize_t ret = 0;
printk("Hello, thread! \n");
/* 创建并启动一个内核线程， 这里参数为线程函数，
* 函数的参数（NULL）,和线程名称。 */
main_task = kthread_run(multhread_server,
NULL,
"multhread_server");
if (IS_ERR(main_task)) {
ret = PTR_ERR(main_task);
goto failed;
}
failed:
return ret;
}
static void multhread_exit(void)
{
printk("Bye thread!\n");
/* 停止线程 */
kthread_stop(main_task);
}
module_init(multhread_init);
module_exit(multhread_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("SunnyZhang<shuningzhang@126.com>");
基本实现原理
创建线程
无论是用户态的进程还是内核线程，在内核态都是线程。在Linux操作系统，创建线程实质是是对父进程（线程）进行克隆的过程。
目前，在3.x以后的版本中，内核线程的创建都有一个名为kthreadd的后台线程操作完成。创建线程的接口只是用于创建任务，并加到任务列表中，并等待后台线程的具体处理。
前文中创建线程的函数kthread_create或者kthread_run调用的函数是__kthread_create_on_node，也就是在某个CPU上创建线程。该函数其实只是创建一个创建线程的请求，如下是裁剪的代码，核心内容如下：
struct task_struct *__kthread_create_on_node(int (*threadfn)(void *data),
void *data, int node,
const char namefmt[],
va_list args)
{
DECLARE_COMPLETION_ONSTACK(done);
struct task_struct *task;
struct kthread_create_info *create = kmalloc(sizeof(*create),
GFP_KERNEL);
if (!create)
return ERR_PTR(-ENOMEM);
create->threadfn = threadfn;
create->data = data;
create->node = node;
create->done = &done;
spin_lock(&kthread_create_lock);
/* 将创建任务添加到链表中 */
list_add_tail(&create->list, &kthread_create_list);
spin_unlock(&kthread_create_lock);
wake_up_process(kthreadd_task);
... ...
}
具体创建工作在名为kthreadd的后台线程中进行，该线程会从队列中获取创建请求，并逐个创建线程。创建线程调用的接口为kernel_thread，该函数实现从父线程克隆子线程的操作，并建立父子线程的关联关系。
线程调度
Linux的线程管理和调度是一个非常复杂的话题，很难用一篇文章说清楚，我们这里只是介绍一下基本原理。目前Linux操作系统默认使用的是CFS调度算法，该算法是基于优先级和时间片的算法，这个算法包含4部分的内容：
- 时间记账
- 进程选择
- 调度器入口
- 睡眠和唤醒
时间记账用于记录进程运行的虚拟时间，而进程选择则是根据策略选择应该将那个进程调度到CPU上运行。进程选择使用的数据结构是红黑树，红黑树是一个自平衡二叉树，也就是其中的数据是有序的，这样可以很容易的找到目的数据。Linux内核在具体实现的时候又使用了一个技巧，也就是将下一个要调度的进程放入缓存中，这样就可以直接找到该进程进行调度，降低了检索时间。
Linux内核的调度入口是schedule函数，当线程调用该函数时将触发线程调度。这个函数实现本身很简单，但其内部调用context_switch函数实现真正的调度，在调用该函数之前会通过调度类获取目的进程。
static __always_inline struct rq *
context_switch(struct rq *rq, struct task_struct *prev,
struct task_struct *next, struct rq_flags *rf)
这样，通过context_switch函数就可以将当前进程调度出去，而将新的进程调度进来。context_switch最终会调度到一个平台相关的函数，而这个函数是汇编语言实现的，主要实现寄存器和堆栈的处理，并最终完成进程的切换。
