Nachos java版学习（二）

threads.Lock类 提 供 了 锁 以 保 证 互 斥。

在 临 界 代 码 区 的 两 端 执 行 Lock.acquire()和Lock.release()即可保证同时只有一个线程访问临界代码区，条件变量建立在锁之上，由threads.Condition实现，它是用来保证同步的工具。每一个条件变量拥有一个锁变量 (该锁变量亦可被执行 acquire 和 release 操作， 多个条件变量可共享同一个锁变量)。当处于临界区内的拥有某锁L的当前线程对与锁L联系的条件变量执行sleep操作时，该线程失去锁 L并被挂起。下一个等待锁 L的线程获得锁 L(这个过程由调度程序完成)并进入临界区。当拥有锁 L 的临界区内的当前线程对与锁 L 联系的条件变量执行 wake 操作时 (通常调用wake之后紧接着就是Lock.release)，等待在该条件变量上的至多一个被挂起的线程 (由调用sleep引起) 被重新唤醒并设置为就绪状态。若执行wakeall操作，则等待在该条件变量上的所有被挂起的线程都被唤醒。

threads.condition已经实现了一个条件变量 (采用信号量实现)，题目要求用屏蔽/禁止中断的方法再实现一下条件变量(写在 threads.condition2中)

 public class Condition2 {
     /**
      * Allocate a new condition variable.
      *
      * @param conditionLock
      *            the lock associated with this condition variable. The current
      *            thread must hold this lock whenever it uses <tt>sleep()</tt>,
      *            <tt>wake()</tt>, or <tt>wakeAll()</tt>.
      */
     public Condition2(Lock conditionLock) {
         this.conditionLock = conditionLock;
         this.waitedThreads = new LinkedList<KThread>();
     }

     /**
      * Atomically release the associated lock and go to sleep on this condition
      * variable until another thread wakes it using <tt>wake()</tt>. The current
      * thread must hold the associated lock. The thread will automatically
      * reacquire the lock before <tt>sleep()</tt> returns.
      */
     public void sleep() {
         Lib.assertTrue(conditionLock.isHeldByCurrentThread());//确定当前进程Held the Block
         boolean intStatus = Machine.interrupt().disable();
         waitedThreads.add(KThread.currentThread());
         conditionLock.release();
         KThread.sleep();
         conditionLock.acquire();
         Machine.interrupt().restore(intStatus);
     }

     /**
      * Wake up at most one thread sleeping on this condition variable. The
      * current thread must hold the associated lock.
      */
     public void wake() {
         Lib.assertTrue(conditionLock.isHeldByCurrentThread());//Test if the current thread holds this lock.
         boolean intStatus = Machine.interrupt().disable();
         if (!waitedThreads.isEmpty())
             waitedThreads.remove().ready();
         Machine.interrupt().restore(intStatus);
     }

     /**
      * Wake up all threads sleeping on this condition variable. The current
      * thread must hold the associated lock.
      */
     public void wakeAll() {
         Lib.assertTrue(conditionLock.isHeldByCurrentThread());
         while (!waitedThreads.isEmpty()) {
             wake();
         }
     }

     private LinkedList<KThread> waitedThreads;
     private Lock conditionLock;
 }