我总结出的内核工作队列中的4种用法

1. 使用系统的工作队列（不延迟）

　　1）定义一个工作：

struct work_struct my_work;

　　2）编写一个函数：

void my_work_func (struct work_struct *p_work)
{
    printk("work func\n");
}

　　3）将工作和函数绑定（一般在open函数里面执行）

INIT_WORK(&my_work, my_work_func);

　　4）调度工作（实际上是加入到系统的工作队列中）

schedule_work(&my_work);

2. 使用系统的工作队列（延迟）

　　1）定义一个延迟工作

struct delayed_work my_delayed_work;

　　2）编写一个函数

void my_work_func (struct work_struct *p_work)
{
    printk("work func\n");
}

　　3）将延迟工作和函数绑定（一般在open函数里进行）

INIT_DELAYED_WORK(&my_delayed_work, my_work_func);

　　4）调度工作（实际上是加入系统的工作队列中）

schedule_delayed_work(&my_delayed_work, 2);
schedule_delayed_work函数传入的第二个参数为系统的节拍数，一般系统默认为200Hz，因此2个节拍表示10ms，10ms之后再调用工作中的函数。

3. 使用自己的工作队列（不延迟）

　　1）定义一个自己的工作队列指针

struct workqueue_struct *p_my_workqueue;

　　2）创建一个工作队列，并接收返回值，可以用create_singlethread_workqueue或者create_workqueue，这一步一般在open函数中实现。

p_my_workqueue = create_singlethread_workqueue("my_workqueue");
//p_my_workqueue = create_workqueue("my_workqueue");

　　3）定义一个工作

struct work_struct my_work;

　　4）编写一个函数

void my_work_func (struct work_struct *p_work)
{
    printk("work func\n");
}

　　5）将工作和函数绑定（一般在open函数里面执行）

INIT_WORK(&my_work, my_work_func);

　　6）将工作插入工作队列中便会调用工作中注册的函数

queue_work(p_my_workqueue, &my_work);

　　7）销毁工作队列

destroy_workqueue(p_my_workqueue);

　

4. 使用自己的工作队列（延迟）

　　1）定义一个自己的工作队列指针

struct workqueue_struct *p_my_workqueue;

　　2）创建一个工作队列，并接收返回值，可以用create_singlethread_workqueue或者create_workqueue，这一步一般在open函数中实现。

p_my_workqueue = create_singlethread_workqueue("my_workqueue");
//p_my_workqueue = create_workqueue("my_workqueue");

　　3）定义一个延迟工作

struct delayed_work my_delayed_work;

　　4）编写一个函数

void my_work_func (struct work_struct *p_work)
{
    printk("work func\n");
}

　　5）将延迟工作和函数绑定（一般在open函数里进行）

INIT_DELAYED_WORK(&my_delayed_work, my_work_func);

　　6）将工作插入工作队列中，n个节拍之后便会调用工作中注册的函数（n为queue_delayed_work函数中最后一个参数）

queue_delayed_work(p_my_workqueue, &my_delayed_work, 2);

　　7）销毁工作队列

destroy_workqueue(p_my_workqueue);

 推荐文章：https://www.ibm.com/developerworks/cn/linux/l-cn-cncrrc-mngd-wkq/