配套的代码可以从本号的github下载： https://github.com/shuningzhang/linux_kernel
内核相关电子书可以在这里下载： https://u19702000.ctfile.com/dir/19702000-33344559-0b7371/
等待队列是一种基于资源状态的线程管理的机制，它可以使线程在资源不满足的情况下处于休眠状态，让出CPU资源，而资源状态满足时唤醒线程，使其继续进行业务的处理。
等待队列（wait queue）用于使线程等待某一特定的事件发生而无需频繁的轮询，进程在等待期间睡眠，在某件事发生时由内核自动唤醒。它是以双循环链表为基础数据结构，与进程的休眠唤醒机制紧密相联，是实现异步事件通知、跨进程通信、同步资源访问等技术的底层技术支撑。
基本接口
wait_queue_head_t
使用等待队列时，最基本的数据结构是struct wait_queue_head_t，也就是等待队列头，这个可以理解为等待队列的实体。队列头中包含一个双向链表，用于记录在该等待队列中处于等待状态的线程等信息。该结构体的定义如下：
struct __wait_queue_head {
spinlock_t lock; //用于互斥访问的自旋锁
struct list_head task_list;
};
typedef struct __wait_queue_head wait_queue_head_t;
可以通过宏定义 DECLARE_WAIT_QUEUE_HEAD直接定义一个队列头变量，并完成初始化，该宏定义如下：
#define DECLARE_WAIT_QUEUE_HEAD(name) \
struct wait_queue_head name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
#define __WAIT_QUEUE_HEAD_INITIALIZER(name) { \
.lock = __SPIN_LOCK_UNLOCKED(name.lock), \
.head = { &(name).head, &(name).head } }
或者是通过结构体wait_queue_head_t定义后，调用函数init_waitqueue_head进行初始化。虽然方式不同，但基本原理是一样的，主要是对结构体内自旋锁和链表的初始化。
wait_event
函数wait_event用于在某个线程中调用，当调用该函数时，如果参数中的条件不满足，则该线程会进入休眠状态。下面代码是该函数的定义：
#define wait_event(wq, condition) \
do { \
if (condition) \
break; \
__wait_event(wq, condition); \
} while (0)
#define __wait_event(wq, condition) \
(void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, 0, schedule())
wake_up
函数wake_up用于对处于阻塞状态的线程进行唤醒，其参数就是队列头。如下是该函数的定义，我们这里暂时不展开介绍。
#define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)
了解了上面1个数据结构及相关函数后就可以使用等待队列了，当然只是基本的使用。
示例程序
我们这里给出一个示例程序，程序很简单。示例程序中有2个线程，分别是服务线程和客户线程。其中服务线程起来后会检查条件是否满足，并视情况进入休眠状态。而客户进程会每隔5秒将条件变成可用状态，并唤醒服务线程。
/* 这个例程用于说明等待队列的用法，在本例程中有2个线程，分别是
* 客户端和服务端。逻辑很简单，服务线程起来的时候会等待事件发生
* 并阻塞，客户端每隔5秒中唤醒一次服务端。*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <linux/socket.h>
#include <net/sock.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/wait.h>
#define BUF_SIZE 1024
struct task_struct *main_task;
struct task_struct *client_task;
wait_queue_head_t wqh;
/* 这个结构体用于在线程之间共享数据 */
struct thread_stat
{
int t_can_run;
};
static inline void sleep(unsigned sec)
{
__set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(sec * HZ);
}
static int multhread_server(void *data)
{
int index = 0;
struct thread_stat* ts = (struct thread_stat*) data;
while (!kthread_should_stop()) {
printk(KERN_NOTICE "server run %d\n", index);
index ++;
/*在这里等待事件， 线程被阻塞在这里。 */
wait_event(wqh, ts->t_can_run || kthread_should_stop());
printk(KERN_NOTICE "server event over!\n");
ts->t_can_run = 0;
}
printk(KERN_NOTICE "server thread end\n");
return 0;
}
static int multhread_init(void)
{
ssize_t ret = 0;
struct thread_stat thread_s;
thread_s.t_can_run = 0;
printk("Hello, multhread \n");
/* 初始化等待队列头 */
init_waitqueue_head(&wqh);
/* 分别启动2个线程 */
main_task = kthread_run(multhread_server,
&thread_s,
"multhread_server");
if (IS_ERR(main_task)) {
ret = PTR_ERR(main_task);
goto failed;
}
client_task = kthread_run(multhread_client,
&thread_s,
"multhread_client");
if (IS_ERR(client_task)) {
ret = PTR_ERR(client_task);
goto client_failed;
}
return ret;
client_failed:
kthread_stop(main_task);
failed:
return ret;
}
static void multhread_exit(void)
{
printk("Bye!\n");
kthread_stop(main_task);
kthread_stop(client_task);
}
module_init(multhread_init);
module_exit(multhread_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("SunnyZhang<shuningzhang@126.com>");
等待队列的原理
关于等待队列的原理，有3点需要重点说明，理解了这几点，也就能够比较清晰的理解等待队列的原理。这3点分别是数据结构、等待函数和唤醒函数。
我们这里还是从结构体说起。这里主要有2个结构体，前面已经有所介绍。其中wait_queue_head是等待队列头，定义如下：
struct wait_queue_head {
spinlock_t lock;
struct list_head head;
};
这里主要是双向链表，所有处于等待状态的线程都被加入到该双向链表中。等后续唤醒时根据该链表中的数据进行唤醒。另外一个数据结构是wait_queue_entry，该结构体是一个等待项，这个结构体对于普通用户通常不必关系，因为内核的API对其进行了封装。
struct wait_queue_entry {
unsigned int flags;
void *private;
wait_queue_func_t func;
struct list_head entry;
};
其中前一个结构体的head成员和后一个结构体的entry成员配合，形成所谓的双向链表。我们先看一下其大概的结构，具体如下图所示。
关于等待函数
关于等待函数，前面给出了一部分定义，下面我们继续深入介绍。在介绍之前，我们先介绍一下其大概流程，本质上就是将当前线程状态设置为TASK_UNINTERRUPTIBLE状态，然后调用schedule函数将本线程调度出去。理解了这个原理，代码就很容易理解，下面是函数的实现：
#define __wait_event(wq_head, condition) \
(void)___wait_event(wq_head, condition, TASK_UNINTERRUPTIBLE, 0, 0, \
schedule())
直接调用的___wait_event函数，注意观察一下这个函数的几个参数，其中TASK_UNINTERRUPTIBLE是目标状态，而schedule则是在内部要调用的函数。
#define ___wait_event(wq_head, condition, state, exclusive, ret, cmd) \
({ \
__label__ __out; \
struct wait_queue_entry __wq_entry; \
long __ret = ret; /* explicit shadow */ \
/* 这里初始化了前文所说的第二个结构体，也就是等待队列项 */ \
init_wait_entry(&__wq_entry, exclusive ? WQ_FLAG_EXCLUSIVE : 0); \
for (;;) { \
/* 这个函数设置线程状态，并将等待队列项添加到等待队列中
*/
long __int = prepare_to_wait_event(&wq_head, &__wq_entry, state);\
/* 满足条件的情况下退出等待 */ \
if (condition) \
break; \
\
if (___wait_is_interruptible(state) && __int) { \
__ret = __int; \
goto __out; \
} \
/* 将线程调度出去 */ \
cmd; \
} \
/*将状态重新设置为TASK_RUNNING，并将队列项移出 */ \
finish_wait(&wq_head, &__wq_entry); \
__out: __ret; \
})
这个函数里面所调用的函数的具体实现就不再解释了，代码贴过来太冗余了，本身也比较简单。
关于唤醒函数
唤醒函数前面也做过简单介绍，我们这里直接进入主体，介绍其实现函数。
static void __wake_up_common_lock(struct wait_queue_head *wq_head,
unsigned int mode,
int nr_exclusive, int wake_flags, void *key)
{
unsigned long flags;
... ...
spin_lock_irqsave(&wq_head->lock, flags);
nr_exclusive = __wake_up_common(wq_head, mode,
nr_exclusive,
wake_flags, key, &bookmark);
spin_unlock_irqrestore(&wq_head->lock, flags);
... ...
}
具体实现在函数__wake_up_common中。代码比较长，我们这里删除不必要的代码，只保留必要的代码逻辑。
static int __wake_up_common(struct wait_queue_head *wq_head, unsigned int mode,
int nr_exclusive, int wake_flags, void *key,
wait_queue_entry_t *bookmark)
{
wait_queue_entry_t *curr, *next;
... ...
/* 主要是这个循环，完成所有等待线程的唤醒， 这里关键是调用func */
list_for_each_entry_safe_from(curr, next, &wq_head->head, entry) {
unsigned flags = curr->flags;
int ret;
/* 这个函数是在init_wait_entry中初始化的，函数的名字是
* autoremove_wake_function，主要完成线程唤醒的动作。 */
ret = curr->func(curr, mode, wake_flags, key);
if (ret < 0)
break;
if (ret && (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
break;
... ...
}
return nr_exclusive;
}
相信介绍到这里，大家应该对等待队列有了比较清晰的认识。总结起来就是要等待的线程加入队列并休眠，当条件满足时有其它线程将处于休眠状态的线程唤醒。
其它接口
本文只介绍了基本的接口，其实系统还提供了很多扩展功能接口，以wake_up为例，还包括如下接口：
#define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)
#define wake_up_nr(x, nr) __wake_up(x, TASK_NORMAL, nr, NULL)
#define wake_up_all(x) __wake_up(x, TASK_NORMAL, 0, NULL)
#define wake_up_locked(x) __wake_up_locked((x), TASK_NORMAL, 1)
#define wake_up_all_locked(x) __wake_up_locked((x), TASK_NORMAL, 0)
#define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
#define wake_up_interruptible_nr(x, nr) __wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
#define wake_up_interruptible_all(x) __wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
#define wake_up_interruptible_sync(x) __wake_up_sync((x), TASK_INTERRUPTIBLE, 1)
接口比较多，这里就不一一介绍了，但使用方法是类似的。
