/* * file mythread.c */

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/init.h>

#include <linux/param.h>

#include <linux/jiffies.h>

#include <asm/system.h>

#include <asm/processor.h>

#include <asm/signal.h>

static pid_t thread_id;

static DECLARE_COMPLETION(exit_completion);

static atomic_t time_to_quit = ATOMIC_INIT(0);

int my_fuction(void *arg) {     

int ret;

daemonize("demo-thread");        

allow_signal(SIGKILL);

complete (&exit_completion);

      while(!signal_pending(current))        

     {                

                printk("jiffies is %lu/n", jiffies);

                set_current_stat(TASK_INTERRUPTIBLE);                                   

               schedule_timeout(10 * HZ);

if (atomic_read(&kthread->terminate))

{ /* we received a request to terminate ourself */ break; }

     }

/*

for(;;)

{

Ret = wait_event_interruptible(wq, condition); //可采用任何同步措施

}*/

  complete_and_exit(&exit_completion, 1); 

  return 0;

}

static int __init init(void)

{        

thread_id = kernel_thread(my_fuction, NULL, CLONE_FS | CLONE_FILES);

wait_for_completion(&exit_completion);

return 0;

}

static void __exit finish(void)

{     

atomic_inc(&time_to_quit); 

        kill_proc(thread_id, SIGKILL, 1); 

        wait_for_completion(&exit_completion);

         printk("Goodbye/n");

}

module_init(init);

module_exit(finish);

MODULE_LICENSE("GPL");

#ifndef _KTHREAD_H

#define _KTHREAD_H

#include <linux/config.h>

#include <linux/version.h>

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/tqueue.h>

#include <linux/wait.h>

#include <asm/unistd.h>

#include <asm/semaphore.h>

/* 新建线程的所以相关信息 */

typedef struct kthread_struct {

/* private data */

/* New Linux task structure of thread ，新建线程的进程数据结构，由current获得*/

struct task_struct *thread;

/* function to be started as thread ，待执行的任务*/

void (*function) (struct kthread_struct *kthread);

/* semaphore needed on start and creation of thread. 新建或清除过程中用来同步建立者和清除者与所建线程 */

struct semaphore startstop_sem;

/* public data */

/* queue thread is waiting on. Gets initialized by init_kthread, can be used by thread itself. 新线程用来或者外部事件的等待队列 */

wait_queue_head_t queue;

/* flag to tell thread whether to die or not. When the thread receives a signal, it must check the value of terminate and call exit_kthread and terminate if set.。killer设置的退出标识 */

atomic_t  terminate;

/* additional data to pass to kernel thread 。传递给新建线程的附加信息，可选*/

void *arg;

} kthread_t;

/* 原型声明*/

/* start new kthread (called by creator) */

void start_kthread(void (*func)(kthread_t *), kthread_t *kthread);

/* stop a running thread (called by "killer") */

void stop_kthread(kthread_t *kthread);

/* setup thread environment (called by new thread) */

void init_kthread(kthread_t *kthread, char *name);

/* cleanup thread environment (called by thread upon receiving termination signal) */

void exit_kthread(kthread_t *kthread);

#endif

#include <linux/config.h>

#include <linux/version.h>

#if defined(MODVERSIONS)

#include <linux/modversions.h>

#endif

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/tqueue.h>

#include <linux/wait.h>

#include <linux/signal.h>

#include <asm/semaphore.h>

#include <asm/smplock.h>

#include "kthread.h"

/* public functions */

/* create a new kernel thread. Called by the creator. */

void start_kthread(void (*func)(kthread_t *), kthread_t *kthread)

{

/* initialize the semaphore: we start with the semaphore locked. The new kernel thread will setup its stuff and unlock it. This control flow (the one that creates the thread) blocks in the down operation below until the thread has reached the up() operation. */

init_MUTEX_LOCKED(&kthread->startstop_sem);

/* store the function to be executed in the data passed to the launcher */

kthread->function=func;

kernel_thread((int (*)(void *))kthread->function, (void *)kthread, 0);

/* wait till it has reached the setup_thread routine */

down(&kthread->startstop_sem);

}

/* stop a kernel thread. Called by the removing instance */

void stop_kthread(kthread_t *kthread)

{

if (kthread->thread == NULL)

{ printk("stop_kthread: killing non existing thread!/n"); return; }

 /* initialize the semaphore. We lock it here, the leave_thread call of the thread to be terminated will unlock it. As soon as we see the semaphore unlocked, we know that the thread has exited. */

init_MUTEX_LOCKED(&kthread->startstop_sem);

/* We need to do a memory barrier here to be sure that the flags are visible on all CPUs. */

mb();

/* set flag to request thread termination */

atomic_inc(&kthread->terminate);

/* We need to do a memory barrier here to be sure that the flags are visible on all CPUs. */

mb();

kill_proc(kthread->thread->pid, SIGKILL, 1);

/* block till thread terminated */

down(&kthread->startstop_sem);

} /*

initialize new created thread. Called by the new thread. */

void init_kthread(kthread_t *kthread, char *name)

{

/* fill in thread structure */

kthread->thread = current; 

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)

/* reparent it to init and give name of “Kthread_example” to the new thread */

daemonize("Kthread_example");

#else

        daemonize();

        strcpy(current->comm, " Kthread_example");

#endif

/* set signal mask to what we want to respond */

allow_signal (SIGKILL| SIGINT| SIGTERM);

/* initialise wait queue */

init_waitqueue_head(&kthread->queue);

/* initialise termination flag */

atomic_set( & kthread->terminate, 0 );

/* tell the creator that we are ready and let him continue */

up(&kthread->startstop_sem);

}

/* cleanup of thread. Called by the exiting thread. */

void exit_kthread(kthread_t *kthread)

{

/* we are terminating */

kthread->thread = NULL;

/* notify the stop_kthread() routine that we are terminating. */

up(&kthread->startstop_sem);

} 

static int __init init(void)

{    

printk("Kernel thread Lib start!/n");

return 0;

}

static void __exit finish(void)

{             

printk("Kernel thread Lib Goodbye!/n");

}

module_init(init); module_exit(finish);

EXPORT_SYMBOL(start_kthread);

EXPORT_SYMBOL(stop_kthread);

EXPORT_SYMBOL(init_kthread);

EXPORT_SYMBOL(exit_kthread);

MODULE_LICENSE("GPL");

 ========================================================================

1 .内核级线程:切换由内核控制，当线程进行切换的时候，由用户态转化为内核态。切换完毕要从内核态返回用户态；可以很好的利用smp，即利用多核cpu。windows线程与Linux pthread大体是这么做的。

 2. 用户级线程内核的切换由用户态程序自己控制内核切换,不需要内核干涉，少了进出内核态的消耗，但不能很好的利用多核Cpu,

线程的实现可以分为两类：用户级线程(User-Level Thread)和内核线线程(Kernel-Level Thread)，后者又称为内核支持的线程或轻量级进程。在多线程操作系统中，各个系统的实现方式并不相同，在有的系统中实现了用户级线程，有的系统中实现了内核级线程。

用户线程指不需要内核支持而在用户程序中实现的线程，其不依赖于操作系统核心，应用进程利用线程库提供创建、同步、调度和管理线程的函数来控制用户线程。不需要用户态/核心态切换，速度快，操作系统内核不知道多线程的存在，因此一个线程阻塞将使得整个进程（包括它的所有线程）阻塞。由于这里的处理器时间片分配是以进程为基本单位，所以每个线程执行的时间相对减少。

内核线程：由操作系统内核创建和撤销。内核维护进程及线程的上下文信息以及线程切换。一个内核线程由于I/O操作而阻塞，不会影响其它线程的运行。Windows NT和2000/XP支持内核线程。

用户线程运行在一个中间系统上面。目前中间系统实现的方式有两种，即运行时系统（Runtime System）和内核控制线程。“运行时系统”实质上是用于管理和控制线程的函数集合，包括创建、撤销、线程的同步和通信的函数以及调度的函数。这些函数都驻留在用户空间作为用户线程和内核之间的接口。用户线程不能使用系统调用，而是当线程需要系统资源时，将请求传送给运行时，由后者通过相应的系统调用来获取系统资源。内核控制线程：系统在分给进程几个轻型进程（LWP），LWP可以通过系统调用来获得内核提供的服务，而进程中的用户线程可通过复用来关联到LWP，从而得到内核的服务。

以下是用户级线程和内核级线程的区别：

（1）内核支持线程是OS内核可感知的，而用户级线程是OS内核不可感知的。

（2）用户级线程的创建、撤消和调度不需要OS内核的支持，是在语言（如Java）这一级处理的；而内核支持线程的创建、撤消和调度都需OS内核提供支持，而且与进程的创建、撤消和调度大体是相同的。

（3）用户级线程执行系统调用指令时将导致其所属进程被中断，而内核支持线程执行系统调用指令时，只导致该线程被中断。

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

（5）用户级线程的程序实体是运行在用户态下的程序，而内核支持线程的程序实体则是可以运行在任何状态下的程序。

内核线程的优点：

（1）当有多个处理机时，一个进程的多个线程可以同时执行。

缺点：

（1）由内核进行调度。

用户进程的优点：

（1） 线程的调度不需要内核直接参与，控制简单。

（2） 可以在不支持线程的操作系统中实现。

（3） 创建和销毁线程、线程切换代价等线程管理的代价比内核线程少得多。

（4） 允许每个进程定制自己的调度算法，线程管理比较灵活。

（5） 线程能够利用的表空间和堆栈空间比内核级线程多。

（6） 同一进程中只能同时有一个线程在运行，如果有一个线程使用了系统调用而阻塞，那么整个进程都会被挂起。另外，页面失效也会产生同样的问题。

缺点：

（1）资源调度按照进程进行，多个处理机下，同一个进程中的线程只能在同一个处理机下分时复用