Lecture Notes for Concurrent Programming

9 July 2002 - Java Synchronization

Java Synchronization

• Class Instance Synchronization

• Mutual Exclusion

• Conditional Synchronization

Class Instance Synchronization

• Every Java class instance has a binary semaphore (a mutex).

  • It is hidden from direct access.

• A class instance mutex is accessed indirectly via synchronized code blocks.

  • A block structured approach to synchronization.

  • A synchronized code block locks at the beginning and unlocks at the end.

    • The code becomes a critical region.

    • Any exit, including exceptions, unlocks the mutex.

• Class methods can be synchronized, as can arbitrary code blocks.

Synchronized Class Methods

• A synchronized class method locks on entry and unlocks on exit.

  • Any exit will do: return, exception.

  • By default methods are unsynchronized.

• The keyword synchronized indicates a synchronized method.

• Synchronized and unsynchronized methods may be mixed in the same class.

  class counter {
    private int count = 0;
    public synchronized void increase() { count++; }
    public int value() { return count; }
    }
  

Synchronized Blocks

• Any code block can be protected in a synchronized block.

  synchronized (class-instance) { code-block }

  • There need be no relation between class-instance and code-block.

• A synchronized method can be implemented with a synchronized block.

  method void f() {
    synchronized (this) {
      // f's body
      }
    }
  

Mutex Behavior

• Mutex unblocking is arbirary.

  • Thread priority is ignored.

  • Thread starvation is possible.

• Mutex locking is re-entrant (or recursive).

  • A thread can relock any mutex it holds.

    class counter
    
      private int counter = 0
    
      public synchronized int 
      increase()
        System.out.println("counter = " + value() + ".")
        count++
    
      public synchronized void 
      value() 
        return count
    

  • Lock-unlock pairs are nested; inner unlocks don't effect outer locks.

  • increase() still holds the lock after the value() call.

Mutual Exclusion

• Any object can be accesed with mutual exclusing using a synchronized block.

  synchronized(obj) {
    // access obj's fields
    }
  

  • This is a convention; a thread may bypass synchronization.

• An object's methods can be declared synchronized.

  public synchronized void 
  change_name(String new_name) {
    // whatever
    }
  

  • This is still a convention; not all methods need be synchronized.

  • The usual member protection applies, preventing direct access.

• Every object instance has its own lock.

Conditional Synchronization

• Binary semaphores can hold waiters until a property is (or could be) true.

• Providing conditional synchronization in Java.

  • Implementing semaphores.

  public synchronized void
  down() {
    // wait until count is positive.
    count--;
    }
  

• How to implment the wait?

  • Spin waiting? while (count < 1) { }?

• The waiting process needs to leave the semaphore, but not exit the method.

  • Leaving the object instance releases the lock.

  • Not exiting the method keeps the thread's place in the method.

• Instances need a back porch where waiters can leave but not exit the instance.

The Wait Set

• The back porch is called the wait set.

  • Like the lock, the wait set is per instance.

  • Wait-set waiters are separate from the mutex waiters.
  

• Note there is only one wait set per class instance.

  • This will cause some pain.

Waiting and Notifying

• The Object methods wait(), notify(), and notifyAll() provide conditional synchronization.

• public void wait() blocks the calling thread in the wait set

  • The calling thread releases the mutex.

  • wait() throws Interrupted Exceptions.

• public void notify() unblocks a thread, if any, in the wait set.

  • The unblocked thread re-acquires the mutex before continuing.

  • The notify is not remembered; if missed, it's gone.

• public void notifyAll() unblocks all threads in the wait set.

  • They all compete for the mutex.

Using Conditional Synchronization

• notify() unblocks an arbitrary thread in the wait set.

  • No fairness, no priority, no nuttin'.

• Wait-set blocked threads may spontaniously unblock.

  • Allowed by the JVM spec and useful for some hardware.

• Contention among notifyAll() threads is high.

• There is only one wait set per object.

  • All conditions look the same to the wait set.

  • notify() may unblock the wrong thread; tends to deadlock.

  • notifyAll() is more important than it should be.

  • This is coarse-grained locking.

Conditional Synchronization and Interference

An unblocked thread may not immediately regain the mutex.
• The signaled condition may no longer be true when it does.

• Upon regaining the instance, it must recheck the condition.

• Bad:

  if (!buffer_full) wait();
  

  • Another thread can beat the waiter to the mutex.

• Good:

  while (!buffer_full) wait();
  

  • Mutual exclusion keeps buffer_full true.

Conditional Synchronization Example

• A One slot buffer.

  class buffer
    private boolean buffer_full = false
    private Object buffer
  
    public synchronized void
    put(Object o)
  
      while (buffer_full) wait()
  
      buffer = 0
      buffer_full = true
  
      notify()
  
    public synchronized Object
    get()
  
      while (!buffer_full) wait()
  
      Object o = buffer
      buffer_full = false
  
      notify()
      return o
  

Points to Remember

• Each object instance has its own mutex.

  • One lock for the whole object.

• Mutexes are accessed indirectly through synchronized code.

  • Either blocks or methods.

• Mutex behavior needs to be worked around.

  • Optional use, weak semantics.

• wait(), notify(), and notifyAll() provide conditional synchronization.

This page last modified on 17 July 2002.