工作队列是将工作推后执行的一种机制，并且可以睡眠。
工作队列结构
定义于#include<linux/workqueue.h> 内核3.1.4 源码位于kernel/workqueue.c
先看工作队列结构
struct work_struct {
atomic_long_t data;
struct list_head entry;
work_func_t func;
#ifdef CONFIG_LOCKDEP
struct lockdep_map lockdep_map;
#endif
};
data的类型是atomic_long_t，只是个原子类型，相当于老版内核中的pending和wq_data的复合体。
entry循环链表结构。
func的参数是work_struct指针，typedef void (*work_func_t)(struct work_struct *work)。
1.怎么把用户的数据作为参数传递给func呢？
与老版2.6.19不同，老版的有定义void* data作为传递参数，而这里是通过container_of来得到用户数据
2.如何延时操作？
老版2.6.19以前有定义timer，这里定义了新的结构delayed_work
struct delayed_work {
struct work_struct work;
struct timer_list timer;
};
创建工作队列
#define create_workqueue(name)\
alloc_workqueue((name), WQ_MEM_RECLAIM, 1)
#define create_freezable_workqueue(name)
\
\
alloc_workqueue((name), WQ_FREEZABLE | WQ_UNBOUND | WQ_MEM_RECLAIM, 1)
#define create_singlethread_workqueue(name)
\
\
alloc_workqueue((name), WQ_UNBOUND | WQ_MEM_RECLAIM, 1)
创建工作
#define DECLARE_WORK(n, f) \
struct work_struct n = __WORK_INITIALIZER(n, f)
#define __WORK_INITIALIZER(n, f) { \
.data = WORK_DATA_STATIC_INIT(),\
.entry
= { &(n).entry, &(n).entry }, \
= { &(n).entry, &(n).entry }, \
.func = (f),\
__WORK_INIT_LOCKDEP_MAP(#n, &(n))\
}
定义名为n的work_struct类型变量，func是work_func_t类型
#define INIT_WORK(_work, _func)\
do {
\
\
__INIT_WORK((_work), (_func), 0);\
} while (0)
#ifdef CONFIG_LOCKDEP
#define __INIT_WORK(_work, _func, _onstack)
\
\
do {
\
\
static struct lock_class_key __key;\
\
__init_work((_work), _onstack);\
(_work)->data = (atomic_long_t) WORK_DATA_INIT();\
lockdep_init_map(&(_work)->lockdep_map, #_work, &__key, 0);\
INIT_LIST_HEAD(&(_work)->entry);\
PREPARE_WORK((_work), (_func));\
} while (0)
#else
#define __INIT_WORK(_work, _func, _onstack)
\
\
do {
\
\
__init_work((_work), _onstack);\
(_work)->data = (atomic_long_t) WORK_DATA_INIT();\
INIT_LIST_HEAD(&(_work)->entry);\
PREPARE_WORK((_work), (_func));\ 工作已提交到工作队列，只需修改该结构
} while (0)
#endif
宏里面还是宏，一层一层的展开，有兴趣的可以研究下。添加work变量，首次构造该结构时使用
提交工作
int queue_work(struct workqueue_struct *wq, struct work_struct *work)
{
int ret;
ret = queue_work_on(get_cpu(), wq, work); // 通过queue_work_on()调用__queue_work()
put_cpu();
return ret;
}
int schedule_work(struct work_struct *work)
{
return queue_work(system_wq, work);
}
对于工作和工作队列的操作，效果是一样 其他也类似
int queue_delayed_work(struct workqueue_struct *wq,
struct delayed_work *dwork, unsigned long delay)
{
if (delay == 0)
return queue_work(wq, &dwork->work);
return queue_delayed_work_on(-1, wq, dwork, delay);
}
延时delay后才被执行
取消工作
bool cancel_delayed_work_sync(struct delayed_work *dwork)
{
return __cancel_work_timer(&dwork->work, &dwork->timer);
}
void flush_workqueue(struct workqueue_struct *wq);
flush_workqueue并不会取消任何延迟执行的工作，因此如果要取消延迟工作，应该调用cancel_delayed_work_sync()。
释放工作队列
void destroy_workqueue(struct workqueue_struct *queue);
用例：
struct my_struct_t {
char *name;
struct work_struct my_work;
};
void my_func(struct work_struct *work)
{
struct my_struct_t *my_name = container_of(work, struct my_struct_t, my_work);
printk(KERN_INFO “my name is %s!\n”, my_name->name);
}
struct workqueue_struct *my_wq; //全局变量
struct my_struct_t my_name; //全局变量
//初始化函数中定义
my_wq = create_workqueue(“my wq”);
my_name.name = “William”;
INIT_WORK(&(my_name.my_work), my_func);
queue_work(my_wq, &(my_name.my_work));
//卸载函数中使用
destroy_workqueue(my_wq);