Lecture Notes for Concurrent Programming

25 July 2002 - Mutex Locks

Mutex Locks

• Syncnronization vs. mutexes.

• Rolling your own.

• Using mutex patterns.

Synchronization

• What's wrong with synchronize?

  • Too simple locking semantics.

    • No testing, timeouts, or interruptions.

  • Fixed and weak lock semantics.

    • Reentrant, waiting fairness.

  • No access control.

    • Instance access provides lock access.

  • Block structured locks and unlocks.

    • No split binaries, no batton passing.

• If you want these, you have to make them.

Custom Locks

• What's wrong with making your own?

  • More cumbersome to use than synchronize.

    • But: use patterns to help.

  • Difficult to enforce correct use mechanically.

    • But: patterns again, and a positive discouragement.

  • Harder to optimize automacially.

    • But: built to exploit problem-specific features.

  • Missing features, such as wait sets.

The Lock Interface.

• A generic locking interface.

  • Lock a lock, blocking if necessary.

  • Unlock a lock.

  • Try to lock a lock.

    • Retry t times, waiting w msec between tries.

    • Return true iff the lock was acquired.

  interface Lock
  
    void lock()
    throws InterruptedException
  
    void unlock()
  
    boolean tryLock(int retries, long wait)
    throws InterruptedException
  

• Locking is interruptable.

The Mutex Lock

• A binary semaphore.

  class Mutex
  implements Lock
  
    private boolean locked
  
    public Mutex(boolean locked)
      this.locked = locked
  

• Lock release.

    public synchronized void unlock()
      locked = false
      notify()
  

Unconditional Lock Acquisition

public void lock()
throws InterruptedException

  if (Thread.interrupted()) 
    throw new InterruptedException()

  synchronized (this)
    try
      while (locked) wait();
      locked = true;
    catch (InterruptedException ie)
      notify();
      throw ie;

• Pass along the thread-interrupt exception.

Conditional Lock Acquisition

public boolean tryLock(int retries, long delay) 
throws InterruptedException

  if (Thread.interrupted()) 
    throw new InterruptedException()

  boolean got_lock

  synchronized (this)

    if (!locked)
      locked = true
      return true

    if ((delay < 1) || (retries < 1))
      return false

    do got_lock = retry(delay)
    while (!got_lock && --retries > 0)

  return got_lock

Lock Retry

• Bound (sorta) the lock attempts.

  private boolean retry(long delay)
    try
      long startTime = System.currentTimeMillis()
      long delayTime = msecs
  
      while (true)
        wait(delayTime)
        if (!locked)
  	locked = true
  	return true
        else
  	long now = System.currentTimeMillis()
  	delayTime = msecs - (now - startTime)
  	if (delayTime <= 0)
  	  return false
    catch (InterruptedException ie)
      notify()
      throw ie
  

• Notice the wait(long) Object method.

General Mutex Use

• A mutex can take the place of a synchronized block.

  synchronize (lock) { /* whatever */ }
  
  try
    mutex.lock()
    try
      // whatever
    finally
      mutex.unlock()
  catch (InterruptedException ie)
    // cancellation behavior.
  

• This is painful syntax; ease the pain with layering.

  • Use a method adapter.

A Mutex Method Adapter

• The method adapter.

  class MutexMethodAdapter
    private final Mutex mutex
  
    MutexMethodAdapter(Mutex m) { mutex = m; }
  
    public void execute(Runnable r)
    throws InterruptedException
      mutex.lock();
      try { r.run(); } 
      finally { mutex.unlock(); }
  

• Example use.

  class counter
    private final MutexMethodAdapter 
      lock = new MutexMethodAdapter(new Mutex(false))
    private long count = 0
  
    private class adder implements Runnable
      private int v
      adder(int v) { this.v = v }
      public void run() { count += v }
  
    public void addTo(int v)
      try { lock.execute(new adder(v)) } 
      catch (Exception e) { }
  

A Mutex Template

• The template.

  abstract class MutexTemplate
  
    private Mutex mutex = new Mutex(false)
  
    void execute(Object o)
      try
        mutex.lock()
        function(o) 
      catch (InterruptedException ie)
        interrupt(ie)
      finally { mutex.unlock() }
    
    abstract protected void 
    function(Object o)
  
    abstract protected void 
    interrupt(InterruptedException ie)
  

• Example use.

  class counter extends MutexTemplate
    private int count = 0
    
    public void addTo(int i)
      function(new Integer(i))
  
    protected void function(Object o)
      count += ((Integer) o).intValue()
  
    protected void interrupt(InterruptedException ie) { }
  

Points to Remember

• You can roll your own, and you'll probably need to.

• Keep it simple; do what you need and no more.

This page last modified on 1 August 2002.