CSE 120: Synchronization Practice

  1. Event
    class Event {
      boolean signaled;
      Lock lock;
      Condition cv;
    
      Event () {
        signaled = false;
        lock = new Lock();
        cv = new Condition(lock);
      }
    
      void wait () {
        lock.acquire();
        while (!signaled) {
          cv.sleep();
        }
        lock.release();
      }
    
      void signal () {
        lock.acquire();
        signaled = true;
        cv.wakeAll();
        lock.release();
      }
    }
    
  2. CountdownEvent
    class CountdownEvent {
      int counter;
      bool signalled;
      Lock lock;
      Condition cv;
    
      CountdownEvent (int count) {
        counter = count;
        if (counter > 0) {
          signalled = false;
        } else {
          signalled = true;
        }
        lock = new Lock();
        cv = new Condition(lock);
      }
    
      void Increment () {
        lock.acquire();
        if (signalled == false) {
          counter++;
        } // otherwise do nothing if already signalled
        lock.release();
      }
    
      void Decrement () {
        lock.acquire();
        if (signalled == false) {
          counter--;
          if (counter == 0) {
            signalled = true;
            cv.wakeAll();
          }
        } // otherwise do nothing if already signalled
        lock.release();
      }
    
      void Wait () {
        lock.acquire();
        if (signalled == false) {
          cv.sleep();
        } // otherwise do nothing if already signalled
        lock.release();
      }
    }
    
  3. Surfing
    class Surfing {
      enum State { calm, breaking; }
      enum Direction { left, right, both; }
      State state;
      Direction breakdir;
      Lock lock;
      Condition left, right;
    
      Surfing () {
        lock = new Lock();
        left = new Condition(lock);
        right = new Condition(lock);
        cv = new Condition(lock);  // for alternate implementation with one cv
        state = calm; breakdir = both;
      }
    
      void paddle (Direction dir) {
        lock.acquire();
        if (state == breaking && (breakdir == dir || breakdir == BOTH)) {
           lock.release();
           return;
        }
        if (dir == left) {
          left.sleep();
        } else {
          right.sleep();
        }
        lock.release();
      }
    
      void wave (Direction dir) {
        lock.acquire();
        state = breaking;
        breakdir = dir;
        if (dir == left) {
          left.wakeAll();
        } else if (dir == right) {
          right.wakeAll();
        } else {
          left.wakeAll();
          right.wakeAll();
        }
        lock.release();
      }
    
      void done () {
        lock.acquire();
        state = calm;
        lock.release();
      }
    }
    
  4. sleepUntil
    // a method of the Condition class
    public void sleepUntil (Callable<boolean> predicate) {
      do {
        this.sleep();  // normal sleep method of the condition variable class
      } while (predicate.call() == false) {
    }