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;
}