第24节提到，在处理中断时，Linux 内核为了解决“又想做得快，又想做得多”的矛盾，将一次完整的中断处理分为“上半部”和“下半部”两部分，耗时较多但是对实时性要求不高的处理统统放入下半部。
2.6.26 版本的 Linux 内核有软中断、tasklet和工作队列三种形式的“下半部”。前面两节主要讨论了软中断和tasklet，我们已经知道软中断处于中断上下文中，因此软中断处理程序不能阻塞，不能睡眠，这就限制了软中断处理程序的发挥。tasklet 也是如此，因为它是基于软中断机制实现的。
Linux 内核中的工作队列
那如果想把下半部的工作推后到进程上下文中完成，或者推后执行的任务需要睡眠时，就需要借助工作队列机制了。Linux 内核会把工作队列中的工作交给内核线程去执行，而内核线程正是运行在进程上下文中的，所以工作队列允许重新调度，也允许其睡眠。
工作队列子系统其实算是一组接口，通过它创建的进程（即所谓的工作者线程）负责执行Linux内核或者其他模块排到工作队列中的任务。Linux 内核提供默认的工作者线程（event/n，n是处理器编号）处理队列中的任务，这样看来，工作队列就变成了一组把延后执行的任务（排入队列中的任务）交给特定线程（默认的工作者线程）处理的接口。
Linux 内核中工作队列使用的数据结构是 workqueue_struct 结构体，它的C语言代码如下，请看：
struct workqueue_struct {
struct cpu_workqueue_struct *cpu_wq;
struct list_head list;
const char *name;
int singlethread;
int freezeable; /* Freeze threads during suspend */
#ifdef CONFIG_LOCKDEP
struct lockdep_map lockdep_map;
#endif
};
容易看出，workqueue_struct 结构体是一个链表的节点，成员 cpu_wq 是多维的，因为每个处理器都对应一个工作者线程，结构体 cpu_workqueue_struct 的C语言代码如下，请看：
struct cpu_workqueue_struct {
spinlock_t lock;
struct list_head worklist;
wait_queue_head_t more_work;
struct work_struct *current_work;
struct workqueue_struct *wq;
struct task_struct *thread;
int run_depth; /* Detect run_workqueue() recursion depth */
} ____cacheline_aligned;
显然，结构体 cpu_workqueue_struct 也会串成一个链表。每个工作者线程关联一个自己的工作队列 wq，thread 成员则负责关联线程。
处理工作队列中的任务
结构体 cpu_workqueue_struct 的成员 current_work 表示工作者线程要处理的工作，它的数据结构由结构体 work_struct 定义，C语言代码如下，请看：
struct work_struct {
atomic_long_t data;
struct list_head entry;
work_func_t func;
};
成员 func 指向处理函数，data 则是它的参数。这些结构被连接成链表，每个处理器上的每种类型的队列都对应这样一个链表，例如前面提到的“默认的工作者线程”就有这样的链表。
当工作者线程被唤醒时，它就会执行链表中所有的工作，执行完毕后，相应的 work_struct 会被从链表上移除。当链表为空时，工作者线程再次进入睡眠。这一过程由 worker_thread() 函数完成，它的C语言代码如下，请看：
299 static int worker_thread(void *__cwq)
- 300 {
...
|- 309 for (;;) {
|| 310 prepare_to_wait(&cwq->more_work, &wait, TASK_INTERRUPTIBLE);
|| 311 if (!freezing(current) &&
|| 312 !kthread_should_stop() &&
|| 313 list_empty(&cwq->worklist))
|| 314 schedule();
|| 315 finish_wait(&cwq->more_work, &wait);
|| 316
|| 317 try_to_freeze();
|| 318
|| 319 if (kthread_should_stop())
|| 320 break;
|| 321
|| 322 run_workqueue(cwq);
|| 323 }
| 324
| 325 return 0;
| 326 }
请看黄框中的核心代码，在for(;;)死循环中，work_thread() 函数将自己设置为 TASK_INTERRUPTIBLE 状态，并加入到等待队列中。如果工作链表为空，则进行一次进程调度，否则结束等待，调用 run_workqueue() 函数执行链表中的工作。run_workqueue() 函数的C语言代码如下，请看：
run_workqueue() 函数的C语言代码虽然长，但是逻辑并不复杂，无非就是从链表取下节点对象，逐个执行，这里就不赘述了。好了，现在已经明白Linux 内核是如何设计和实现工作队列的了，再来看看如何使用它。
使用工作队列
Linux 内核定义了 DECLARE_WORK 宏用于静态创建 work_struct 结构体，它的C语言代码如下，请看：
#define DECLARE_WORK(n, f) \
struct work_struct n = __WORK_INITIALIZER(n, f)
#define __WORK_INITIALIZER(n, f) { \
.data = WORK_DATA_INIT(), \
.entry = { &(n).entry, &(n).entry }, \
.func = (f), \
__WORK_INIT_LOCKDEP_MAP(#n, &(n)) \
}
其实就是创建一个 work_struct 结构体并赋值。当然，也可以在C语言程序运行时，使用 INIT_WORK 宏通过指针创建一个工作，INIT_WORK 宏的C语言代码如下，请看：
#define INIT_WORK(_work, _func) \
do { \
(_work)->data = (atomic_long_t) WORK_DATA_INIT(); \
INIT_LIST_HEAD(&(_work)->entry); \
PREPARE_WORK((_work), (_func)); \
} while (0)
再来看看工作队列的处理函数，它的原型如下：
void work_handler(void *data);
这个函数由工作者线程执行，因此运行在进程上下文中，允许响应中断，且可以睡眠可以被调度。工作就创建好之后，可以通过 schedule_work() 函数将其交给默认工作线程处理，它的C语言代码如下，请看：
int schedule_work(struct work_struct *work)
{
return queue_work(keventd_wq, work);
}
容易看出， schedule_work() 函数其实就是把 work 加入到全局工作队列 keventd_wq 中，这一动作由 queue_work() 函数完成，它的C语言代码如下：
int queue_work(struct workqueue_struct *wq, struct work_struct *work)
{
int ret = 0;
if (!test_and_set_bit(WORK_STRUCT_PENDING, work_data_bits(work))) {
BUG_ON(!list_empty(&work->entry));
__queue_work(wq_per_cpu(wq, get_cpu()), work);
put_cpu();
ret = 1;
}
return ret;
}
容易看出，queue_work() 函数的核心功能由__queue_work() 函数完成，它的C语言代码如下：
到这里就明白了，其实 schedule_work() 函数的核心就是将工作 work 加入到工作队列中，排队等待被执行。
当然，Linux 内核也允许创建新的工作者线程，但是并不推荐，所以相关分析留给读者自己了。
小节
到这里，Linux 内核中关于中断“下半部”的三种类型就粗略的分析完了。“软中断”适合处理对实时性要求高，需要频繁执行的工作，但是需确保共享数据的同步安全性。tasklet 能确保同一类型的工作不会在多个处理器上同时运行，但是它是基于“软中断”实现的，因此和“软中断”一样处于中断上下文中，不能睡眠不能阻塞。如果推后执行的工作需要在进程上下文中运行，则应选择工作队列。
