Linux进程休眠和唤醒

矫情吗；* 2022-04-16 05:25 886阅读 1赞

**分享一下我老师大神的人工智能教程！零基础，通俗易懂！[http://blog.csdn.net/jiangjunshow][http_blog.csdn.net_jiangjunshow]**

**也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！**

**当进程以阻塞的方式通信，在得到结果前进程会挂起休眠。  
为了将进程以一种安全的方式进入休眠，我们需要牢记两条规则：  
一、永远不要在原子上下文中进入休眠。  
二、进程休眠后，对环境一无所知。唤醒后，必须再次检查以确保我们等待的条件真正为真**

**简单休眠  
完成唤醒任务的代码还必须能够找到我们的进程，这样才能唤醒休眠的进程。需要维护一个称为等待队列的数据结构。等待队列就是一个进程链表，其中包含了等待某个特定事件的所有进程。  
linux维护一个“等待队列头”来管理，wait\_queue\_head\_t,定义在<linux/wait.h>  
struct \_\_wait\_queue\_head \{  
wq\_lock\_t lock;  
struct list\_head task\_list;  
\};  
typedef struct \_\_wait\_queue\_head wait\_queue\_head\_t;  
初始化方法：  
静态方法：  
DECLARE\_WAIT\_QUEUE\_HEAD(name)  
动态方法：  
wait\_queue\_head\_t my\_queue;  
init\_waitqueue\_head(&my\_queue);**

**linux中最简单的休眠方式是下面的宏，  
wait\_event(queue, condition) /\*进程将被置于非中断休眠（uninterruptible sleep）\*/  
wait\_event\_interruptible(queue, condition) /\*进程可被信号中断休眠,返回非0值表示休眠被信号中断\*/  
wait\_event\_timeout(queue, condition, timeout) /\*等待限定时间jiffy，condition满足其一返回0\*/  
wait\_event\_interruptible\_timeout(queue, condition, timeout)  
queue是等待队列头，传值方式  
condition是任意一个布尔表达式，在休眠前后多次对condition求值，为真则唤醒**

**唤醒进程的基本函数是wake\_up  
void wake\_up(wait\_queue\_head\_t \*queue); /\*唤醒等待在给定queue上的所有进程\*/  
void wake\_up\_interruptible(wait\_queue\_head\_t \*queue);**

**实践中，一般是wait\_event和wake\_up，wait\_event\_interruptible和wake\_up\_interruptible成对使用**

**高级休眠  
将进程置于休眠的步骤：  
（1）分配和初始化一个 wait\_queue\_t 结构， 随后将其添加到正确的等待队列**

**struct \_\_wait\_queue \{ unsigned int flags;\#define WQ\_FLAG\_EXCLUSIVE 0x01 void \*private; wait\_queue\_func\_t func; struct list\_head task\_list;\};typedef struct \_\_wait\_queue wait\_queue\_t;（2）设置进程状态，标记为休眠。2.6内核中，使用下面的函数：  
void set\_current\_state(int new\_state);  
在 <linux/sched.h> 中定义有几个任务状态：TASK\_RUNNING 意思是进程能够运行。有 2 个状态指示一个进程是 在睡眠: TASK\_INTERRUPTIBLE 和 TASK\_UNTINTERRUPTIBLE**

**（3）最后一步是放弃处理器。 但必须先检查进入休眠的条件。如果不做检查会引入竞态： 如果在忙于上面的这个过程时有其他的线程刚刚试图唤醒你，你可能错过唤醒且长时间休眠。因此典型的代码下  
if (!condition)  
schedule( ); /\*调用调度器，并让出CPU\*/  
如果代码只是从 schedule 返回，则进程处于TASK\_RUNNING 状态。 如果不需睡眠而跳过对 schedule 的调用，必须将任务状态重置为 TASK\_RUNNING，还必要从等待队列中去除这个进程，否则它可能被多次唤醒。**

**手工休眠  
上面的进程休眠步骤可通过手工设置：  
（1）创建和初始化一个等待队列。常由宏定义完成:  
DEFINE\_WAIT(my\_wait);  
name 是等待队列入口项的名字. 也可以用2步来做:  
wait\_queue\_t my\_wait;  
init\_wait(&my\_wait);  
常用的做法是放一个 DEFINE\_WAIT 在循环的顶部，来实现休眠**

**（2）添加等待队列入口到队列，并设置进程状态:  
void prepare\_to\_wait(wait\_queue\_head\_t \*queue,  
wait\_queue\_t \*wait,  
int state);  
queue 和 wait 分别地是等待队列头和进程入口。state 是进程的新状态：TASK\_INTERRUPTIBLE(可中断休眠，推荐)或TASK\_UNINTERRUPTIBLE(不可中断休眠，不推荐)**

**（3）在检查确认仍然需要休眠之后调用 schedule  
if (!condition)  
schedule( ); /\*调用调度器，并让出CPU\*/**

**（4）schedule 返回，就到了清理时间:  
void finish\_wait(wait\_queue\_head\_t \*queue, wait\_queue\_t \*wait);**

**认真地看简单休眠中的 wait\_event(queue, condition) 和 wait\_event\_interruptible(queue, condition) 底层源码会发现，其实他们只是手工休眠中的函数的组合。所以怕麻烦的话还是用wait\_event比较好。**

**独占等待  
当一个进程调用 wake\_up 在等待队列上，所有的在这个队列上等待的进程被置为可运行的。 这在许多情况下是正确的做法。但有时，可能只有一个被唤醒的进程将成功获得需要的资源，而其余的将再次休眠。这时如果等待队列中的进程数目大，这可能严重降低系统性能。为此，内核开发者增加了一个“独占等待”选项。它与一个正常的睡眠有 2 个重要的不同:  
（1）当等待队列入口设置了 WQ\_FLAG\_EXCLUSEVE 标志，它被添加到等待队列的尾部；否则，添加到头部。  
（2）当 wake\_up 被在一个等待队列上调用, 它在唤醒第一个有 WQ\_FLAG\_EXCLUSIVE 标志的进程后停止唤醒.但内核仍然每次唤醒所有的非独占等待。  
采用独占等待要满足 2 个条件:  
（1）希望对资源进行有效竞争；  
（2）当资源可用时，唤醒一个进程就足够来完全消耗资源。  
使一个进程进入独占等待，可调用：  
void prepare\_to\_wait\_exclusive(wait\_queue\_head\_t \*queue, wait\_queue\_t \*wait, int state);  
注意：无法使用 wait\_event 和它的变体来进行独占等待.**

**唤醒函数  
很少会需要调用wake\_up\_interruptible 之外的唤醒函数，但为完整起见，这里是整个集合：  
wake\_up(wait\_queue\_head\_t \*queue);  
wake\_up\_interruptible(wait\_queue\_head\_t \*queue);  
wake\_up 唤醒队列中的每个非独占等待进程和一个独占等待进程。wake\_up\_interruptible 同样, 除了它跳过处于不可中断休眠的进程。它们在返回之前, 使一个或多个进程被唤醒、被调度(如果它们被从一个原子上下文调用, 这就不会发生).  
wake\_up\_nr(wait\_queue\_head\_t \*queue, int nr);  
wake\_up\_interruptible\_nr(wait\_queue\_head\_t \*queue, int nr);  
这些函数类似 wake\_up, 除了它们能够唤醒多达 nr 个独占等待者, 而不只是一个. 注意传递 0 被解释为请求所有的互斥等待者都被唤醒  
wake\_up\_all(wait\_queue\_head\_t \*queue);  
wake\_up\_interruptible\_all(wait\_queue\_head\_t \*queue);  
这种 wake\_up 唤醒所有的进程, 不管它们是否进行独占等待(可中断的类型仍然跳过在做不可中断等待的进程)  
wake\_up\_interruptible\_sync(wait\_queue\_head\_t \*queue);  
一个被唤醒的进程可能抢占当前进程, 并且在 wake\_up 返回之前被调度到处理器。 但是, 如果你需要不要被调度出处理器时，可以使用 wake\_up\_interruptible 的"同步"变体. 这个函数最常用在调用者首先要完成剩下的少量工作，且不希望被调度出处理器时。**

#### 给我老师的人工智能教程打call！[http://blog.csdn.net/jiangjunshow][http_blog.csdn.net_jiangjunshow] ####

![这里写图片描述][SouthEast]

[http_blog.csdn.net_jiangjunshow]: https://blog.csdn.net/jiangjunshow/article/details/77338485
[SouthEast]: /images/20220416/046124877f20488587d965d7600c924a.png