实现锁和条件变量

实现锁和条件变量，这个基本都是在参考别人的代码，然后自己慢慢理解.突然觉得自己好弱阿，不但写不出代码，看别人写的都要看半天才明白....打击颇大，要继续加油了.不然以后只好去中关村卖电脑了.

1.实现锁
锁和信号量的区别在于锁只有两个状态，0或者1，同一时间只能有1个线程进入临界区，所以也叫互斥量，还有一个区别时，为锁添加了占用锁的当前线程属性。
修改synch.h文件，为Lock添加两个私有属性，拥有锁的线程和互斥信号量.

    Thread* holder;            // 拥有锁的线程
    Semaphore* lock;            // 互斥信号

实现方法
在构造函数中初始化该变量.信号量只能有两个状态BUSY 和 FREE
    holder = NULL;
    lock = new Semaphore(name,1);

加锁和解锁的操作都是原子的，必须屏蔽中断.执行P操作,并设置当前占用线程
加锁操作
void Lock::Acquire()
{
    IntStatus oldLevel = interrupt->SetLevel(IntOff);  // disable interrupts       
    lock->P();                                                                     // procure the semaphore
    holder = currentThread;                                          
    (void) interrupt->SetLevel(oldLevel); // re-enable interrupts
}
解锁操作，当前占用锁的进程为空，释放锁
void Lock::Release()
{
       IntStatus oldLevel = interrupt->SetLevel(IntOff);  // disable interrupts
       ASSERT(currentThread == holder);        
       holder = NULL;                        
       lock->V();                            
    (void) interrupt->SetLevel(oldLevel);
}

2.实现条件变量
条件变量通常和锁一起使用，所有对条件变量的操作必须保证当前线程占有互斥锁。
所以在条件变量中声明一个锁和一个等待该条件变量的队列。
    List* queue;            //等待条件变量的线程队列
    Lock* lock;                //用来判断锁是否被当线程占用
构造函数初始化：
    queue = new List;
    lock = NULL;
当执行Wait操作时，当他不能获得期待的一个条件变量时，线程进入等待状态，原子性的调用并解锁它锁持有的互斥量，
当另一个线程向它发送信号时，它可以继续执行。

void Condition::Wait(Lock* conditionLock)
{
    IntStatus oldLevel = interrupt->SetLevel(IntOff);

    ASSERT(conditionLock->isHeldByCurrentThread()); 
    if(queue->IsEmpty()) {
    lock = conditionLock;                                                  // 当等待队列为空时，绑定该条件变量和互斥锁。
    }
    ASSERT(lock == conditionLock);
    queue->Append(currentThread);                             //当前线程添加到该条件变量的等待队列中
    conditionLock->Release();                                        //释放当前锁，使得其他线程可以进入临界区
    currentThread->Sleep();                                            //当前线程进入等待状态
    conditionLock->Acquire();                                         //当其他线程发送一个信号后，当前线程wake up，并获得锁
    (void) interrupt->SetLevel(oldLevel);
}

//发送信号，从等待队列中获得一个线程并启动
void Condition::Signal(Lock* conditionLock)
{
    Thread *nextThread;
    IntStatus oldLevel = interrupt->SetLevel(IntOff);

    ASSERT(conditionLock->isHeldByCurrentThread());
    if(!queue->IsEmpty()) {
    ASSERT(lock == conditionLock);
    nextThread = (Thread *)queue->Remove();
    scheduler->ReadyToRun(nextThread);     
    }
    (void) interrupt->SetLevel(oldLevel);
}

//广播，使等待队列中每一个线程都启动
void Condition::Broadcast(Lock* conditionLock)
{
    Thread *nextThread;
    IntStatus oldLevel = interrupt->SetLevel(IntOff);

    ASSERT(conditionLock->isHeldByCurrentThread());
    if(!queue->IsEmpty()) {
    ASSERT(lock == conditionLock);
    while(nextThread = (Thread *)queue->Remove()) {
        scheduler->ReadyToRun(nextThread, 0); 
    }
    }
    (void) interrupt->SetLevel(oldLevel);
}