bool testAndSet (bool& b) {
        bool valueToReturn = b;
        b = true;
        return valueToReturn;
    }

    procedure Spin (R: Resource) is
    begin
        loop
            select
                R.Sieze;
                return;
            else
                null;
            end select;
        end loop;
    end Spin;

    protected type Transient_Broadcast_Signal is
      entry Wait;
      entry Send;
    private
      entry Reset;
      Signalled: Boolean := False;
    end Transient_Broadcast_Signal;

    protected body Transient_Broadcast_Signal is
      entry Wait when Signalled is
      begin
        null;
      end Wait;
      entry Send when True is
      begin
        if Wait'Count > 0 then
          Signalled := True;
          requeue Reset;
        end if
      end Send;
      entry Reset when Wait'Count > 0 is
      begin
        Signalled := True;
      end Reset;
    end Transient_Broadcast_Signal;

But you can reimplement it so that it doesn't use requeue, doesn't need private entries, and in fact has null bodies for all the protected operations! In other words all the functionality is in the barriers. Implement this cool solution.

    class C {
      X x = new X();
      void f() {notify();}
      synchronized void g() {x.q();}
    }

The reason is that the body of X.q() could contain a call to C.f() so a thread that calls C.g() would obtain the lock on entry to g(), and retain it through its execution of X.q() and C.f(). However, in the following code, can we say for sure that an IllegalMonitorStateException WILL be thrown by any thread executing C.f()?

    class C {
      void f() {notify();}
    }

Why or why not?

    class Planet extends Thread {
        private double r, u, x, y, du;
        public Planet(double r, double du) {this.r=r; this.du=du; x=r; y=u=0;}
        public void run() {while (true) {u+=du; x=r*cos(u); y=r*sin(u);}}
        public Point getPosition() {return new Point(x, y);}
    }

class Counter {
    private int value;
    private int max;
    public Counter(int max) {value = 0; this.max = max;}
    public synchronized void add(int n) {
        while (value+n > max) try {wait();} catch (InterruptedException e) {}
        value += n;
        notifyAll();
    }
    public synchronized void subtract(int n) {
        while (value < n) try {wait();} catch (InterruptedException e) {}
        value -= n;
        notifyAll();
    }
}

Explain in detail a scenario in which deadlock occurs only if the notifyAll() calls were replaced with notify() calls. That is, there is no deadlock with notifyAll() but there IS deadlock with notify().

    thread1:                           thread2:
      while (true) {                     while (true) {
        NON_CRITICAL_SECTION_1             NON_CRITICAL_SECTION_2
        while (turn != 1);                 while (turn != 2);
        CRITICAL_SECTION_1                 CRITICAL_SECTION_2
        turn = 2;                          turn = 1;
      }                                  }

public class MySemaphoreBasedCountDown {
    Semaphore s;
    ...
    public MySemaphoreBasedCountDown(int count) {...}
    public void await() throws InterruptedException {...}
    public void countDown() {...}
}

Make objects of your class work like Java CountDownLatches, meaning you can only use them once.

    if not T'Terminated then
        T.E;
    end if;

1. Assuming the plain old FIFO queue has methods

       add(Object)
       Object remove()
       isEmpty()
       isFull()
   

   and assuming the existence of methods

       Object produce()
       consume(Object)
   

   write the run() methods for the producer and consumer. Assume both methods have access to the same Exchanger object.
2. Can this solution be easily generalized to a situation in which there is 1 producer but n consumers? Why or why not? (I'm looking for a kind of specific answer here....)