本文转载自微信公众号「Linux内核远航者」，作者Linux内核远航者。转载本文请联系Linux内核远航者公众号。
以sleep为例来说明任务在用户态是如何睡眠的。
首先我们通过strace工具来看下其调用的系统调用：
复制
![[[412976]]](https://s3.51cto.com/oss/202107/26/10fae5b9e9c10e1da63a8e97ae3203d5.jpg){kind=link}
$ strace sleep 1 ... close(3) = 0 clock_nanosleep(CLOCK_REALTIME, 0, {tv_sec=1, tv_nsec=0}, NULL) = 0 close(1) = 0 ...
1.
2.
3.
4.
5.
6.
7.
可以发现sleep主要调用clock_nanosleep系统调用来进行睡眠(也就是说用户态任务睡眠需要调用系统调用陷入内核)。
下面我们来研究下clock_nanosleep的实现(这里集中到睡眠的实现，先忽略掉定时器等诸多的技术细节)：
复制
kernel/time/posix-timers.c SYSCALL_DEFINE4(clock_nanosleep ->const struct k_clock *kc = clockid_to_kclock(which_clock); //根据时钟类型得到内核时钟结构 return kc->nsleep(which_clock, flags, &t); //调用内核时钟结构的nsleep回调
1.
2.
3.
4.
5.
我们传递过来的时钟类型为CLOCK_REALTIME，则调用链为：
复制
kc->nsleep(CLOCK_REALTIME, flags, &t) ->clock_realtime.nsleep ->common_nsleep ->hrtimer_nanosleep //kernel/time/hrtimer.c ->hrtimer_init_sleeper_on_stack ->__hrtimer_init_sleeper ->__hrtimer_init(&sl->timer, clock_id, mode); //初始化高精度定时器 sl->timer.function = hrtimer_wakeup; //设置超时回调函数 sl->task = current;.//设置超时时要唤醒的任务 ->do_nanosleep //睡眠操作
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
可以看到，睡眠函数最终调用到hrtimer_nanosleep，它调用了两个主要函数：__hrtimer_init_sleeper和do_nanosleep，前者主要设置高精度定时器，后者就是真正的睡眠，主要来看下 do_nanosleep：
复制
kernel/time/hrtimer.c do_nanosleep -> do { set_current_state(TASK_INTERRUPTIBLE); //设置可中断的睡眠状态 hrtimer_sleeper_start_expires(t, mode); //开启高精度定时器 if (likely(t->task)) freezable_schedule(); //主动调度 hrtimer_cancel(&t->timer); mode = HRTIMER_MODE_ABS; } while (t->task && !signal_pending(current)); //是否记录的有任务且没有挂起的信号 __set_current_state(TASK_RUNNING); //设置为可运行状态
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
do_nanosleep函数是睡眠的核心实现：首先设置任务的状态为可中断的睡眠状态，然后开启了之前设置的高精度定时器，随即调用freezable_schedule进行真正的睡眠。
来看下freezable_schedule：
复制
//include/linux/freezer.h freezable_schedule ->schedule() ->__schedule(false);
1.
2.
3.
4.
5.
可以看到最终调用主调度器__schedule进行主动调度。
当任务睡眠完成，定时器超时，会调用之前在__hrtimer_init_sleeper设置的超时回调函数hrtimer_wakeup将睡眠的任务唤醒(关于进程唤醒在这里就不在赘述，在后面的进程唤醒专题文章在进行详细解读)，然后就可以再次获得处理器的使用权了。
总结：处于用户态的任务，如果想要睡眠一段时间必须向内核请求服务(如调用clock_nanosleep系统调用)，内核中会设置一个高精度定时器，来记录要睡眠的任务，然后设置任务状态为可中断的睡眠状态，紧接着发生主动调度，这样任务就发生睡眠了。
当任务处于内核态时，有时候也需要睡眠一段时间，不像任务处于用户态需要发生系统调用来请求内核进行睡眠，在内核态可以直接调用睡眠函数。当然，内核态中，睡眠有两种场景：一种是睡眠特定的时间的延迟操作(唤醒条件为超时)，一种是等待特定条件满足(如IO读写完成，可睡眠的锁被释放等)。
下面分别以msleep和mutex锁为例讲解内核态睡眠：
5.1 msleep
msleep做ms级别的睡眠延迟。
复制
//kernel/time/timer.c void msleep(unsigned int msecs) { unsigned long timeout = msecs_to_jiffies(msecs) + 1; //ms时间转换为jiffies while (timeout) timeout = schedule_timeout_uninterruptible(timeout); //不可中断睡眠 }
1.
2.
3.
4.
5.
6.
7.
8.
下面看下schedule_timeout_uninterruptible：
这里涉及到一个重要数据结构process_timer
复制
struct process_timer { struct timer_list timer; //定时器结构 struct task_struct *task; //定时器到期要唤醒的任务 };
1.
2.
3.
4.
复制
schedule_timeout_uninterruptible -> __set_current_state(TASK_UNINTERRUPTIBLE); //设置任务状态为不可中断睡眠 return schedule_timeout(timeout); ->expire = timeout + jiffies; //计算到期时的jiffies值 timer.task = current; //记录定时器到期要唤醒的任务 为当前任务 timer_setup_on_stack(&timer.timer, process_timeout, 0); //初始化定时器 超时回调为process_timeout __mod_timer(&timer.timer, expire, MOD_TIMER_NOTPENDING); //添加定时器 schedule(); //主动调度
1.
2.
3.
4.
5.
6.
7.
8.
再看下超时回调为process_timeout：
复制
process_timeout ->struct process_timer *timeout = from_timer(timeout, t, timer); //通过定时器结构获得process_timer wake_up_process(timeout->task); //唤醒其管理的任务
1.
2.
3.
可以看到，msleep实现睡眠也是通过定时器，首先设置当前任务状态为不可中断睡眠，然后设置定时器超时时间为传递的ms级延迟转换的jiffies,超时回调为process_timeout，然后将定时器添加到系统中，最后调用schedule发起主动调度，当定时器超时的时候调用process_timeout来唤醒睡眠的任务。
5.2 mutex锁
mutex锁是可睡眠锁的一种，当申请mutex锁时发现其他内核路径已经持有这把锁，当前任务就会睡眠等待在这把锁上。
下面我们来看他的实现，主要看睡眠的部分：
复制
kernel/locking/mutex.c mutex_lock ->__mutex_lock_slowpath ->__mutex_lock(lock, TASK_UNINTERRUPTIBLE, 0, NULL, _RET_IP_) //睡眠的状态为不可中断睡眠 ->__mutex_lock_common -> ... waiter.task = current; //记录需要唤醒的任务为当前任务 set_current_state(state); //设置睡眠状态 for (;;) { if (__mutex_trylock(lock)) //尝试获得锁 goto acquired; schedule_preempt_disabled(); ->schedule(); //主动调度 } acquired： __set_current_state(TASK_RUNNING);//设置状态为可运行状态
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
可以看到mutex锁实现睡眠套路和之前是一样的：申请mutex锁的时候，如果其他内核路径已经持有这把锁，首先通过mutex锁的相关结构来记录下当前任务，然后设置任务状态为不可中断睡眠，接着在一个for循环中调用schedule_preempt_disabled发生主动调度，于是当前任务就睡眠在这把锁上。当其他内核路径释放了这把锁，就会唤醒等待在这把锁上的任务，当前任务就获得了这把锁，然后进入锁的临界区，唤醒操作就完成了(关于唤醒的技术细节，后面的唤醒专题会详细讲解)。
进程睡眠按照应用场景可以分为：延迟睡眠和等待某些特定条件而睡眠，实际上都可以归于等待某些特定条件而睡眠，因为延迟特定时间也可以作为特定条件。进程睡眠按照进程所处的特权级别可以分为：用户态进程睡眠和内核态进程睡眠，用户态进程睡眠需要进程通过系统调用陷入内核来发起睡眠请求。对于进程睡眠，内核主要需要做三大步操作：1.设置任务状态为睡眠状态 2.记录睡眠的任务 3.发起主动调度。这三大步操作都是非常有必要，第一步设置睡眠状态为后面调用主调度器做必要的标识准备;第二步记录下睡眠的任务是为了以后唤醒任务来准备的;第三步是睡眠的主体部分，这里会将睡眠的任务从运行队列中踢出，选择下一个任务运行。