pintos (4) --Mesa vs. Hoare style

关注

原创最新推荐文章于 2026-03-16 00:17:10 发布 1.4k 阅读 AI 写同款· GEO 优化 ›

【pintos学习笔记】(2)睡眠“忙等待” 一、问题描述在pintos里，实现进程睡眠是依靠timer_sleep(ticks)函数。该函数的实现是将进程“睡眠”后，利用Polling的机制不断中断当前CPU内的进程，使得CPU时间不能够让给别的进程，造成一个”忙等待”的现象。这有点像一个俗语——“站着茅坑不拉shi”，把CPU时间一直紧紧攥着，然后也不让别的进程去完成任务了。而且这个进程也并有真正睡着，一直在问我到底阅读详情

在阅读pintos/src/threads/synch.c的时候，发现了一个令人疑惑的地方：

/* Down or "P" operation on a semaphore. Waits for SEMA's value
to become positive and then atomically decrements it.
This function may sleep, so it must not be called within an
interrupt handler. This function may be called with
interrupts disabled, but if it sleeps then the next scheduled
thread will probably turn interrupts back on. */
void
sema_down (struct semaphore *sema)
{
    enum intr_level old_level;

    ASSERT (sema != NULL);
    ASSERT (!intr_context ());

    old_level = intr_disable ();
    while (sema->value == 0)
    {
        list_push_back (&sema->waiters, &thread_current ()->elem);
        thread_block ();
    }
    sema->value--;
    intr_set_level (old_level);
}

这个函数是信号量的P操作，完成的功能就是

关中断
判断信号量是否为0
- 如果为0，当前进程加入该sema等待队列
- 不为0，sema–，继续执行
还原中断

第16行使用了while而不是if，为什么要在这里循环呢？
sema为0陷入阻塞之后，一定是被V操作唤醒的，既然是V操作，那么sema一定不为0，while的意义在哪里呢？

先来看一下V操作：

/* Up or "V" operation on a semaphore.  Increments SEMA's value
   and wakes up one thread of those waiting for SEMA, if any.
   This function may be called from an interrupt handler. */
void
sema_up (struct semaphore *sema) 
{
  enum intr_level old_level;

  ASSERT (sema != NULL);

  old_level = intr_disable ();
  if (!list_empty (&sema->waiters)) 
    thread_unblock (list_entry (list_pop_front (&sema->waiters),
                                struct thread, elem));
  sema->value++;
  intr_set_level (old_level);
}

V操作做了如下的事情

关中断
如果waiters队列有进程，执行thread_unblock()
sema++
还原中断

好像没什么不对的

再来看一下thread_unblock()的实现：

/* Transitions a blocked thread T to the ready-to-run state.
   This is an error if T is not blocked.  (Use thread_yield() to
   make the running thread ready.)
   This function does not preempt the running thread.  This can
   be important: if the caller had disabled interrupts itself,
   it may expect that it can atomically unblock a thread and
   update other data. */
void
thread_unblock (struct thread *t) 
{
  enum intr_level old_level;

  ASSERT (is_thread (t));

  old_level = intr_disable ();
  ASSERT (t->status == THREAD_BLOCKED);
  list_push_back (&ready_list, &t->elem);
  t->status = THREAD_READY;
  intr_set_level (old_level);
}