内核线程 VS 用户线程

一 用户线程和内核线程概述

在传统的操作系统中，拥有资源和独立调度的基本单位都是进程。在引入线程的操作系统中，线程是独立调度的基本单位，进程是资源拥有的基本单位。在同一进程中，线程的切换不会引起进程切换。在不同进程中进行线程切换,如从一个进程内的线程切换到另一个进程中的线程时，会引起进程切换。进程是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存等）的基本单位。在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。线程包含了表示进程内执行环境必须的信息，其中包括进程中表示线程的线程ID、一组寄存器值、栈、调度优先级和策略、信号屏蔽字、errno常量以及线程私有数据。进程的所有信息对该进程的所有线程都是共享的，包括可执行的程序文本、程序的全局内存和堆内存、栈以及文件描述符。在Unix和类Unix操作系统中线程也被称为轻量级进程（lightweight processes），但轻量级进程更多指的是内核线程（kernel thread），而把用户线程（user thread）称为线程。

内核线程：内核线程切换由内核控制，当线程进行切换的时候，由用户态转化为内核态。切换完毕要从内核态返回用户态。当有多个处理机时，一个进程的多个线程可以同时执行。

用户线程：用户级线程内核的切换由用户态程序自己控制内核切换,不需要内核干涉，少了进出内核态的消耗，但不能很好的利用多核Cpu。线程的调度不需要内核直接参与，控制简单而且创建和销毁线程、线程切换代价等线程管理的代价比内核线程少得多。但是同一进程中只能同时有一个线程在运行，如果有一个线程使用了系统调用而阻塞，那么整个进程都会被挂起。

用户线程和内核线程的区别：
1 内核支持线程是OS内核可感知的，而用户级线程是OS内核不可感知的。

2 在只有用户级线程的系统内，CPU调度还是以进程为单位，处于运行状态的进程中的多个线程，由用户程序控制线程的轮换运行；在有内核支持线程的系统内，CPU调度则以线程为单位，由OS的线程调度程序负责线程的调度。

二 内核线程kernel thread 简单使用

感谢 https://blog.csdn.net/ezimu/article/details/60467017 前辈的分析，此处摘抄自 eZiMu 大神的分析

1 内核线程的创建 - kernel_thread()

可以用kernel_thread()，kthread_create() kthread_run()三种方式创建内核线程

kernel_thread()：是一种比较老的API，不推荐经常使用

extern pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);

使用 ： 这个例子运行，会每隔3秒n加1，并打印出来

#include <linux/module.h> 
#include <linux/moduleparam.h> 
#include <linux/init.h>
#include <linux/kmod.h>
#include <linux/sched.h> 
#include <linux/delay.h>

MODULE_AUTHOR("zimu");
MODULE_LICENSE("GPL");

#define CLONE_KERNEL    (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)

int my_kernel_thread(void *arg)
{
	 int n = 0;
	 while(1)
	{
	 printk("%s: %d\n",__func__,n++);
	  ssleep(3);
	}
	 return 0;
}

static int __init practiceCall(void) 
{ 
	printk("%s:\n",__func__); 
	kernel_thread(my_kernel_thread,NULL,CLONE_KERNEL); 
	return 0;
 }
 
static void __exit practiceCallExit(void)
{
        printk("%s:\n",__func__);
}

module_init(practiceCall);
module_exit(practiceCallExit);

2 内核线程的创建 - kthread_create()

#define kthread_create(threadfn, data, namefmt, arg…)
\
kthread_create_on_node(threadfn, data, namefmt, ##arg)

参数说明：
threadfn:线程函数地址
data:线程函数形参，如果没有可以定义为NULL
namefmt,arg…:线程函数名字，可以格式化输出名字。

注意 ：kthread_create()创建后，线程没有立即运行，需要将返回的值，即线程指针（struct task_struct *）,作为参数传入到wake_up_process()唤起线程运行。在编写线程循环体时，一般都要加入kthread_should_stop(),如果不加，调用kthread_stop()是没有效果的，也会导致模块退出后，线程仍然还在运行。

使用：
这个例子运行，每隔3秒n加1，并输出，当退出模块时，调用了kthread_stop()函数，当my_kernel_kernel()运行到if(kthread_should_stop())时，条件为真，退出while(1){…}线程退出停止。

#include <linux/module.h> 
#include <linux/moduleparam.h> 
#include <linux/init.h> 
#include <linux/kmod.h> 
#include <linux/sched.h> 
#include <linux/delay.h> 
#include <linux/kthread.h>

MODULE_AUTHOR("zimu");
MODULE_LICENSE("GPL");

#define CLONE_KERNEL    (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)

strcut task_struct *practice_task_p = NULL;

int my_kernel_thread(void *arg) 
{ 
	int n = 0; 
	while(1) 
	{ 
			printk("%s: %d\n",__func__,n++); 
			ssleep(3);
			if(kthread_should_stop()) 
			{ 
			break; 
			} 
		}
	 return 0; 
 }


static int __init practiceCall(void) 
{ 
	printk("%s:\n",__func__); 
	practice_task_p = kthread_create(my_kernel_thread,NULL,"practice task"); 
	if(!IS_ERR(practice_task_p)) 
	wake_up_process(practice_task_p); 
	return 0; 
}

static void __exit practiceCallExit(void)
{
        printk("%s:\n",__func__);
        kthread_stop(practice_task_p);
}

module_init(practiceCall);
module_exit(practiceCallExit);

3 内核线程的创建 - kthread_run():

kthread_run()是基于kthread_create()来实现的。并且kthread_run()创建的线程，是立刻运行的。

使用 ：
例子运行后，也是每隔3秒n加1，并且打印出来。卸载模块时，kthread_stop()通知线程退出。

#include <linux/module.h> 
#include <linux/moduleparam.h> 
#include <linux/init.h> 
#include <linux/kmod.h> 
#include <linux/sched.h> 
#include <linux/delay.h> 
#include <linux/kthread.h> 

MODULE_AUTHOR("zimu");
MODULE_LICENSE("GPL");

#define CLONE_KERNEL    (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)


int my_kernel_thread(void *arg)
{
      int n = 0;

	  while(1)
	 {
	                printk("%s: %d\n",__func__,n++);
	                ssleep(3);
	        if(kthread_should_stop())
	        {
	                        break;
	        }
	}

        return 0;
}

static int __init practiceCall(void)
{
        printk("%s:\n",__func__);
         practice_task_p = kthread_run(my_kernel_thread,NULL,"practice task");    

        return 0;
}

static void __exit practiceCallExit(void)
{
        printk("%s:\n",__func__);
        kthread_stop(practice_task_p);
}
module_init(practiceCall);
module_exit(practiceCallExit);

4 内核线程的挂起

线程的stop（kthread_stop()）状态，是指线程终止，线程的生命周期结束。线程的park状态（kthread_park()），是指线程暂时停止（可以理解就是挂起），当执行换线（kthread_unpark()）后，线程从挂起状态唤醒，接着运行。

使用：
当在其他某个地方，调用kthread_park(practice_task_p)后，线程将在kthread_parkme()处挂起睡眠，直到其他某个地方执行了kthread_unpark(practice_task_p)后，线程才被唤起，继续执行。

#include <linux/module.h> 
#include <linux/moduleparam.h> 
#include <linux/init.h> 
#include <linux/kmod.h> 
#include <linux/sched.h> 
#include <linux/delay.h> 
#include <linux/kthread.h> 

MODULE_AUTHOR("zimu");
MODULE_LICENSE("GPL");

#define CLONE_KERNEL    (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)

int my_kernel_thread(void *arg)
{
        int n = 0;

        while(1)
        {
                printk("%s: %d\n",__func__,n++);
                ssleep(3);
                if(kthread_should_park())
           	    kthread_parkme();

		        if(kthread_should_stop())
		        {
		                        break;
		        }
        }

    return 0;
}

static int __init practiceCall(void)
{
        printk("%s:\n",__func__);
        practice_task_p = kthread_run(my_kernel_thread,NULL,"practice task");    

         return 0;
}

static void __exit practiceCallExit(void)
{
        printk("%s:\n",__func__);
        kthread_stop(practice_task_p);
}
module_init(practiceCall);
module_exit(practiceCallExit);

三 用户线程的简单使用

待续。。。