共计 7931 个字符，预计需要花费 20 分钟才能阅读完成。
本文丸趣 TV 小编为大家详细介绍“linux 有没有内核级线程”，内容详细，步骤清晰，细节处理妥当，希望这篇“linux 有没有内核级线程”文章能帮助大家解决疑惑，下面跟着丸趣 TV 小编的思路慢慢深入，一起来学习新知识吧。
linux 有内核级线程，linux 支持内核级的多线程。Linux 内核可以看作服务进程（管理软硬件资源，响应用户进程的各种进程）；内核需要多个执行流并行，为了防止可能的阻塞，支持多线程。内核线程就是内核的一个分身，可以用以处理一件特定事情，内核线程的调度由内核负责，一个内核线程的处于阻塞状态时不影响其他的内核线程。
线程通常被定义为一个进程中代码的不同执行路线。从实现方式上划分，线程有两种类型：“用户级线程”和“内核级线程”。
用户线程指不需要内核支持而在用户程序中实现的线程，其不依赖于操作系统核心，应用进程利用线程库提供创建、同步、调度和管理线程的函数来控制用户线程。这种线程甚至在象 DOS 这样的操作系统中也可实现，但线程的调度需要用户程序完成，这有些类似 Windows 3.x 的协作式多任务。
另外一种则需要内核的参与，由内核完成线程的调度。其依赖于操作系统核心，由内核的内部需求进行创建和撤销，这两种模型各有其好处和缺点。
用户线程不需要额外的内核开支，并且用户态线程的实现方式可以被定制或修改以适应特殊应用的要求，但是当一个线程因 I/O 而处于等待状态时，整个进程就会被调度程序切换为等待状态，其他线程得不到运行的机会；而内核线程则没有各个限制，有利于发挥多处理器的并发优势，但却占用了更多的系统开支。
Windows NT 和 OS/ 2 支持内核线程。Linux 支持内核级的多线程。
linux 中的内核级线
1. 内核线程概述
Linux 内核可以看作服务进程（管理软硬件资源，响应用户进程的各种进程）
内核需要多个执行流并行，为了防止可能的阻塞，支持多线程。
内核线程就是内核的一个分身，可以用以处理一件特定事情，内核线程的调度由内核负责，一个内核线程的处于阻塞状态时不影响其他的内核线程。
内核线程是直接由内核本身启动的进程。内核线程实际上是将内核函数委托给独立的进程执行，它与内核中的其他“进程”并行执行。内核线程经常被称之为内核守护进程。当前的内核中，内核线程就负责下面的工作：
周期性地将修改的内存页与页来源块设备同步
实现文件系统的事务日志
内核线程由内核创建，所以内核线程在内核态执行，只能访问内核虚拟地址空间，不能访问用户空间。
在 linux 所有的线程都当作进程来实现，也没有单独为线程定义调度算法以及数据结构，一个进程相当于包含一个线程，就是自身，多线程，原本的线程称为主线程，他们一起构成线程组。
进程拥有自己的地址空间，所以每个进程都有自己的页表，而线程却没有，只能和其它线程共享主线程的地址空间和页表
2. 三个数据结构
每个进程或线程由三个重要的数据结构，分别是 struct thread_info, struct task_struct 和内核栈。
thread_info 对象存放的进程 / 线程的基本信息，它和进程 / 线程的内核栈存放在内核空间里的一段 2 倍页长空间中。其中 thread_info 结构存放在地址段的末尾，其余空间作为内核栈。内核使用伙伴系统分配这段空间。
struct thread_info {
int preempt_count; /* 0 = preemptable, 0 = bug */
struct task_struct *task; /* main task structure */
__u32 cpu; /* cpu */};thread_info 结构体中有一个 struct task_struct *task，task 指向该线程或者进程的 task_struct 对象，task_struct 也叫做任务描述符：
struct task_struct {
pid_t pid;
pid_t tgid;
void *stack;
struct mm_struct *mm, *active_mm;
/* filesystem information */
struct fs_struct *fs;
/* open file information */
struct files_struct *files;};#define task_thread_info(task) ((struct thread_info *)(task)- stack)stack：是指向进程或者线程的 thread_info
mm：对象用来管理该进程 / 线程的页表以及虚拟内存区
active_mm：主要用于内核线程访问主内核页全局目录
pid：每个 task_struct 都会有一个不同的 id，就是 pid
tgid：线程组领头线程的 PID，就是主线程的 pid
linux 系统上虚拟地址空间分为两个部分：供用户态程序访问的虚拟地址空间和供内核访问的内核空间。每当内核执行上下文切换时，虚拟地址空间的用户层部分都会切换，以便匹配运行的进程，内核空间的部分是不会切换的。
3. 内核线程创建
在内核版本 linux-3.x 以后，内核线程的创建被延后执行，并且交给名为 kthreadd 2 号线程执行创建过程，但是 kthreadd 本身是怎么创建的呢？过程如下：
pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
{
return do_fork(flags|CLONE_VM|CLONE_UNTRACED, (unsigned long)fn,
(unsigned long)arg, NULL, NULL);
}
pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);kthreadadd 本身最终是通过 do_fork 实现的，do_fork 通过传入不同的参数，可以分别用于创建用户态进程 / 线程，内核线程等。当 kthreadadd 被创建以后，内核线程的创建交给它实现。
内核线程的创建分为创建和启动两个部分，kthread_run 作为统一的接口，可以同时实现，这两个功能：
#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; \
})
#define kthread_create(threadfn, data, namefmt, arg...) \
kthread_create_on_node(threadfn, data, -1, namefmt, ##arg)
struct task_struct *kthread_create_on_node(int (*threadfn)(void *data),
void *data, int node,
const char namefmt[],
...)
{
DECLARE_COMPLETION_ONSTACK(done);
struct task_struct *task;
/* 分配 kthread_create_info 空间 */
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;
/* 加入到 kthread_creta_list 列表中，等待 ktherad_add 中断线程去创建改线程 */
spin_lock(kthread_create_lock);
list_add_tail(create- list, kthread_create_list);
spin_unlock(kthread_create_lock);
wake_up_process(kthreadd_task);
/*
* Wait for completion in killable state, for I might be chosen by
* the OOM killer while kthreadd is trying to allocate memory for
* new kernel thread.
*/
if (unlikely(wait_for_completion_killable( done))) {
/*
* If I was SIGKILLed before kthreadd (or new kernel thread)
* calls complete(), leave the cleanup of this structure to
* that thread.
*/
if (xchg( create- done, NULL))
return ERR_PTR(-EINTR);
/*
* kthreadd (or new kernel thread) will call complete()
* shortly.
*/
wait_for_completion(done);
}
task = create- result;
.
.
.
kfree(create);
return task;
}kthread_create_on_node 函数中：
首先利用 kmalloc 分配 kthread_create_info 变量 create，利用函数参数初始化 create
将 create 加入 kthread_create_list 链表中，然后唤醒 kthreadd 内核线程创建当前线程
唤醒 kthreadd 后，利用 completion 等待内核线程创建完成，completion 完成后，释放 create 空间
下面来看下 kthreadd 的处理过程：
int kthreadd(void *unused)
{
struct task_struct *tsk = current;
/* Setup a clean context for our children to inherit. */
set_task_comm(tsk, kthreadd
ignore_signals(tsk);
set_cpus_allowed_ptr(tsk, cpu_all_mask);
set_mems_allowed(node_states[N_MEMORY]);
current- flags |= PF_NOFREEZE;
for (;;) {
set_current_state(TASK_INTERRUPTIBLE);
if (list_empty( kthread_create_list))
schedule();
__set_current_state(TASK_RUNNING);
spin_lock(kthread_create_lock);
while (!list_empty( kthread_create_list)) {
struct kthread_create_info *create;
create = list_entry(kthread_create_list.next,
struct kthread_create_info, list);
list_del_init(create- list);
spin_unlock(kthread_create_lock);
create_kthread(create);
spin_lock(kthread_create_lock);
}
spin_unlock(kthread_create_lock);
}
return 0;
}kthreadd 利用 for(;;) 一直驻留在内存中运行：主要过程如下：
检查 kthread_create_list 为空时，kthreadd 让出 cpu 的执行权
kthread_create_list 不为空时，利用 while 循环遍历 kthread_create_list 链表
每取下一个链表节点后调用 create_kthread，创建内核线程
static void create_kthread(struct kthread_create_info *create)
{
int pid;
/* We want our own signal handler (we take no signals by default). */
pid = kernel_thread(kthread, create, CLONE_FS | CLONE_FILES | SIGCHLD);
if (pid 0) {
/* If user was SIGKILLed, I release the structure. */
struct completion *done = xchg(create- done, NULL);
if (!done) {
kfree(create);
return;
}
create- result = ERR_PTR(pid);
complete(done);
}
}可以看到内核线程的创建最终还是和 kthreadd 一样，调用 kernel_thread 实现。
static int kthread(void *_create)
{
.
.
.
.
/* If user was SIGKILLed, I release the structure. */
done = xchg(create- done, NULL);
if (!done) {
kfree(create);
do_exit(-EINTR);
}
/* OK, tell user we re spawned, wait for stop or wakeup */
__set_current_state(TASK_UNINTERRUPTIBLE);
create- result = current;
complete(done);
schedule();
ret = -EINTR;
if (!test_bit(KTHREAD_SHOULD_STOP, self.flags)) {
__kthread_parkme(self);
ret = threadfn(data);
}
/* we can t just return, we must preserve self on stack */
do_exit(ret);
}kthread 以 struct kthread_create_info 类型的 create 为参数，create 中带有创建内核线程的回调函数，以及函数的参数。kthread 中，完成 completion 信号量的处理，然后 schedule 让出 cpu 的执行权，等待下次返回 时，执行回调函数 threadfn(data)。
4. 内核线程的退出
线程一旦启动起来后，会一直运行，除非该线程主动调用 do_exit 函数，或者其他的进程调用 kthread_stop 函数，结束线程的运行。
int kthread_stop(struct task_struct *k)
{
struct kthread *kthread;
int ret;
trace_sched_kthread_stop(k);
get_task_struct(k);
kthread = to_live_kthread(k);
if (kthread) {
set_bit(KTHREAD_SHOULD_STOP, kthread- flags);
__kthread_unpark(k, kthread);
wake_up_process(k);
wait_for_completion(kthread- exited);
}
ret = k- exit_code;
put_task_struct(k);
trace_sched_kthread_stop_ret(ret);
return ret;
}如果线程函数正在处理一个非常重要的任务，它不会被中断的。当然如果线程函数永远不返回并且不检查信号，它将永远都不会停止。在执行 kthread_stop 的时候，目标线程必须没有退出，否则会 Oops。所以在创建 thread_func 时，可以采用以下形式：
thread_func()
{
// do your work here
// wait to exit
while(!thread_could_stop())
{
wait();
}
}
exit_code()
{
kthread_stop(_task); // 发信号给 task，通知其可以退出了
}如果线程中在等待某个条件满足才能继续运行，所以只有满足了条件以后，才能调用 kthread_stop 杀掉内核线程。
5. 内核线程使用
#include test_kthread.h
#include linux/delay.h
#include linux/timer.h
#include linux/platform_device.h
#include linux/fs.h
#include linux/module.h
static struct task_struct *test_thread = NULL;
unsigned int time_conut = 5;
int test_thread_fun(void *data)
{
int times = 0;
while(!kthread_should_stop())
{
printk(\n printk %u\r\n , times);
times++;
msleep_interruptible(time_conut*1000);
}
printk(\n test_thread_fun exit success\r\n\n
return 0;
}
void register_test_thread(void)
{
test_thread = kthread_run(test_thread_fun , NULL, test_kthread);
if (IS_ERR(test_thread)){
printk(KERN_INFO create test_thread failed!\n
}
else {
printk(KERN_INFO create test_thread ok!\n
}
}
static ssize_t kthread_debug_start(struct device *dev, struct device_attribute *attr, char *buf)
{
register_test_thread();
return 0;
}
static ssize_t kthread_debug_stop(struct device *dev, struct device_attribute *attr, char *buf)
{
kthread_stop(test_thread);
return 0;
}
static DEVICE_ATTR(kthread_start, S_IRUSR, kthread_debug_start,NULL);
static DEVICE_ATTR(kthread_stop, S_IRUSR, kthread_debug_stop,NULL);
struct attribute * kthread_group_info_attrs[] =
{
dev_attr_kthread_start.attr,
dev_attr_kthread_stop.attr,
NULL,
};
struct attribute_group kthread_group =
{
.name = kthread ,
.attrs = kthread_group_info_attrs,
};读到这里，这篇“linux 有没有内核级线程”文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注丸趣 TV 行业资讯频道。
