Semaphores in Java

Java Monitors

• To enter the block, a thread must acquire the lock first. When a lock is "locked", all threads trying to acquire the lock will wait until the lock has been released by the holding thread. The lock is "unlocked" when a thread leaves the block. Only one thread can hold the lock at a time. This is implemented in the Java Virtual Machine. Remember that the state of the implicit binary semaphore is "unlocked" or "1".

If obj is an object, then a thread can acquire it in the following way:

synchronized (obj) {
  critical section of code
}

• Any object in any synchronized block can be used as an implicit binary semaphore.
• If all methods needing mutually exclusive access are in the same object, the lock can be acquired through:

synchronized (this) {...}

• If the entire body of a method must have exclusive access to one thread at a time, the entire method can be declared as synchronized:

type method (...) {
  synchronized (this) {
  critical section;
  }
}

The Java compiler allows:

synchronized type method{
  critical section;
}

• If critical sections requiring mutual exclusion must be spread across multiple classes, then we must declare an object whose lock can be accessed across all classes. In the example below, the object "mutex" is used to prevent multiple simultaneous invocations of the function "fn".

{...
private Object mutex = null;
  ...
mutex = this //in the constructor
  ...
  public void run() {
    for (int m = 1; m <= M; m++)
      synchronized (mutex) {
        sum = fn(sum, m);
      }
    }
...
}

• As another example, for a bank account, you can prevent simultaneous access by you and the auditor threads as follows:

class ATM{...
  synchronized (mutex) {
savingsAccount[fromAccount] -= amount;
savingsAccount[toAccount] += amount;
  }
}

class Auditor{...
  synchronized ( mutex) {
    for (int i = 0; i < numAccounts; I++)
      total += savingsAccount[i];
  }
}

• Remember that binary semaphores are used for mutual exclusion synchronization and for condition synchronization. For example:

shared binary semaphore S

in one thread

if (!condition) P(S);

in another thread

V(S);

Semaphores Implemented in Java

Semaphore Class

• Since locks associated with objects can only be initialized to "unlocked", below is a binary semaphore class which can be used for condition synchronization.

public abstract class Semaphore{
  protected int value = 0;
  protected Semaphore() {value = 0;} //constructors
  protected Semaphore(int initial) {value = initial;}
  public synchronized void P() {
    value--;
    if (value < 0)
      try {wait(); } catch (InterruptedException e) {}
  }

public synchronized void V() {
    value++; if (value>=0) notify();
  }
}

Binary and Counting Semaphore Classes

public class BinarySemaphore extends Semaphore{
  public BinarySemaphore() {super();} //constructors
  public BinarySemaphore(int initial)
    {super((initial!=0) ? 1:0);}
  public BinarySemaphore(boolean initial)
    {super(initial ? 1:0);}
    public final synchronized void V() {
super.V();
      if (value > 1) value = 1; // max value of binary semaphore
    }
}

public class CountingSemaphore extends Semaphore {
  public CountingSemaphore() {super();} //constructors
  public CountingSemaphore(int initial) {super(initial);}
}

Notification Objects

shared object:

Object obj = new Object();

in one thread:

synchronized (obj) { ...
    if ( !condition)
      try {obj.wait();} catch (InterruptedException e) {}
  ...
  }

in another thread:

synchronized (obj) {...
    if (condition) obj.notify():
    ...
  }

• When used inside a monitor, a notification object plays the role of a named condition variable.
• In example below, methods 2 and 4 deal with setting and testing conditions.
• Note that the hierarchy of locking could cause a "deadlock" state.

class Name {

  Object obj = new Object();
  other data fields;
  public type method1(...) {...
    synchronized (obj) {...
      if (!method2(...))
        try{obj.wait();} catch (Interrupted Exception e) {}
      ...
    }
  ...
  }

private synchronized boolean method2(...) {...}

public type method3 (...) {...
    synchronized (obj) {...
      if (method4(...)) obj.notify();
    ...
    }
  ...
  }

private synchronized boolean method4(...) {...}
}