技术员博客      html  css  js  c++  java
  • linux 内核线程

    创建内核线程:
    struct task_struct *kthread_create(int (*threadfn)(void *data),
    void *data, const char namefmt[]);

    唤醒内核线程(可以唤醒所有进程(线程)):
    wake_up_process(struct task_struct *k);

    创建并运行内核线程:
    struct task_struct *kthread_run(int (*threadfn)(void *data),
    void *data, const char namefmt[]);

    通知内核线程停止:
    int kthread_stop(struct task_struct *k);
    返回threadfn函数的返回值, 如果k没有被wake_up_process(k)过将返回-EINTR
    不是强制停止, 如果内核线程不停止将一直等待

    检查是否收到停止信号:
    int kthread_should_stop(void);

    kthread_create与kernel_thread的区别

    从表面上来看,这两个函数非常的类似,但是实现却是相差甚远。
    kthread_create是通过work_queue来实现的,kernel_thread是通过do_fork来实现的。

    kernel thread可以用kernel_thread创建,但是在执行函数里面必须用daemonize释放资源并挂到init下,还需要用 completion等待这一过程的完成。


    kthread_create是比较正牌的创建函数,这个不必要调用daemonize,用这个创建的kernel thread都挂在了kthread线程下。

    可以在非内核线程中调用kernel_thread, 但这样创建的线程必须在自己调用daemonize(...)来释放资源,成为真正的内核线程。

    #include <linux/kernel.h>
    #include <linux/module.h>
    static int noop(void *dummy)
    {
    int i = 0;
    daemonize("mythread");
    while(i++ < 5) {
    printk("current->mm = %p\n", current->mm);
    printk("current->active_mm = %p\n", current->active_mm);
    set_current_state(TASK_INTERRUPTIBLE);
    schedule_timeout(10 * HZ);
    }
    return 0;
    }
    static int test_init(void)
    {
    kernel_thread(noop, NULL, CLONE_KERNEL | SIGCHLD);
    return 0;
    }
    static void test_exit(void) {}
    module_init(test_init);
    module_exit(test_exit);

    ”mythread“就是给这个内核线程取的名字, 可以用ps -A来查看。
    schedule()用于进程调度, 可以理解为放弃CPU的使用权.

    kthread_create创建线程

    1 使用kthread_create创建线程:
    struct task_struct *kthread_create(int (*threadfn)(void *data),
    void *data,
    const char *namefmt, ...);
    这个函数可以像printk一样传入某种格式的线程名
    线程创建后,不会马上运行,而是需要将kthread_create() 返回的task_struct指针传给wake_up_process(),然后通过此函数运行线程。
    2. 当然,还有一个创建并启动线程的函数:kthread_run
    struct task_struct *kthread_run(int (*threadfn)(void *data),
    void *data,
    const char *namefmt, ...);
    3. 线程一旦启动起来后,会一直运行,除非该线程主动调用do_exit函数,或者其他的进程调用kthread_stop函数,结束线程的运行。
    int kthread_stop(struct task_struct *thread);
    kthread_stop() 通过发送信号给线程。
    如果线程函数正在处理一个非常重要的任务,它不会被中断的。当然如果线程函数永远不返回并且不检查信号,它将永远都不会停止。
    参考:Kernel threads made easy
    --
    view plaincopy to clipboardprint?
    #include <linux/kthread.h>
    static struct task_struct * _task;
    static struct task_struct * _task2;
    static struct task_struct * _task3;
    static int thread_func(void *data)
    {
    int j,k;
    int timeout;
    wait_queue_head_t timeout_wq;
    static int i = 0;
    i++;
    j = 0;
    k = i;
    printk("thread_func %d started\n", i);
    init_waitqueue_head(&timeout_wq);
    while(!kthread_should_stop())
    {
    interruptible_sleep_on_timeout(&timeout_wq, HZ);
    printk("[%d]sleeping..%d\n", k, j++);
    }
    return 0;
    }
    void my_start_thread(void)
    {

    //_task = kthread_create(thread_func, NULL, "thread_func2");
    //wake_up_process(_task);
    _task = kthread_run(thread_func, NULL, "thread_func2");
    _task2 = kthread_run(thread_func, NULL, "thread_func2");
    _task3 = kthread_run(thread_func, NULL, "thread_func2");
    if (!IS_ERR(_task))
    {
    printk("kthread_create done\n");
    }
    else
    {
    printk("kthread_create error\n");
    }
    }
    void my_end_thread(void)
    {
    int ret = 0;
    ret = kthread_stop(_task);
    printk("end thread. ret = %d\n" , ret);
    ret = kthread_stop(_task2);
    printk("end thread. ret = %d\n" , ret);
    ret = kthread_stop(_task3);
    printk("end thread. ret = %d\n" , ret);
    }
    #include <linux/kthread.h>
    static struct task_struct * _task;
    static struct task_struct * _task2;
    static struct task_struct * _task3;
    static int thread_func(void *data)
    {
    int j,k;
    int timeout;
    wait_queue_head_t timeout_wq;
    static int i = 0;
    i++;
    j = 0;
    k = i;
    printk("thread_func %d started\n", i);
    init_waitqueue_head(&timeout_wq);
    while(!kthread_should_stop())
    {
    interruptible_sleep_on_timeout(&timeout_wq, HZ);
    printk("[%d]sleeping..%d\n", k, j++);
    }
    return 0;
    }
    void my_start_thread(void)
    {

    //_task = kthread_create(thread_func, NULL, "thread_func2");
    //wake_up_process(_task);
    _task = kthread_run(thread_func, NULL, "thread_func2");
    _task2 = kthread_run(thread_func, NULL, "thread_func2");
    _task3 = kthread_run(thread_func, NULL, "thread_func2");
    if (!IS_ERR(_task))
    {
    printk("kthread_create done\n");
    }
    else
    {
    printk("kthread_create error\n");
    }
    }
    void my_end_thread(void)
    {
    int ret = 0;
    ret = kthread_stop(_task);
    printk("end thread. ret = %d\n" , ret);
    ret = kthread_stop(_task2);
    printk("end thread. ret = %d\n" , ret);
    ret = kthread_stop(_task3);
    printk("end thread. ret = %d\n" , ret);
    }
    在执行kthread_stop的时候,目标线程必须没有退出,否则会Oops。原因很容易理解,当目标线程退出的时候,其对应的task结构也变得无效,kthread_stop引用该无效task结构就会出错。
    为了避免这种情况,需要确保线程没有退出,其方法如代码中所示:
    thread_func()
    {
    // do your work here
    // wait to exit
    while(!thread_could_stop())
    {
    wait();
    }
    }
    exit_code()
    {
    kthread_stop(_task);//发信号给task,通知其可以退出了
    }
    这种退出机制很温和,一切尽在thread_func()的掌控之中,线程在退出时可以从容地释放资源,而不是莫名其妙地被人“暗杀”。


  • 相关阅读:
    教你理解复杂的CC++声明(转)
    敏捷建模
    CAS做单点登陆(SSO)——集成BIEE 11g
    最近研究Swing,找到的几个网址 规格严格
    APSW Another Python SQLite Wrapper
    创业公司3Gear Systems利用Kinect打造未来人机交互体验 | 36氪
    用gevent来host wsgi server,mysql能否长连接
    【Visual C++】游戏开发笔记之七——基础动画显示(一)定时器的使用
    TeamCola 最好用的团队工作日志软件
    Extern point 初步注解
  • 原文地址:https://www.cnblogs.com/javawebsoa/p/3019627.html
Copyright © 2011-2022 技术员博客