net.wimpi.modbus.util

Class Mutex

java.lang.Object

net.wimpi.modbus.util.Mutex

public class Mutex
extends Object

A simple non-reentrant mutual exclusion lock. The lock is free upon construction. Each acquire gets the lock, and each release frees it. Releasing a lock that is already free has no effect.

This implementation makes no attempt to provide any fairness or ordering guarantees. If you need them, consider using one of the Semaphore implementations as a locking mechanism.

Sample usage

Mutex can be useful in constructions that cannot be expressed using java synchronized blocks because the acquire/release pairs do not occur in the same method or code block. For example, you can use them for hand-over-hand locking across the nodes of a linked list. This allows extremely fine-grained locking, and so increases potential concurrency, at the cost of additional complexity and overhead that would normally make this worthwhile only in cases of extreme contention.

 class Node {
   Object item;
   Node next;
   Mutex lock = new Mutex(); // each node keeps its own lock
   Node(Object x, Node n) { item = x; next = n; }
 }
 class List {
    protected Node head; // pointer to first node of list
    // Use plain java synchronization to protect head field.
    //  (We could instead use a Mutex here too but there is no
    //  reason to do so.)
    protected synchronized Node getHead() { return head; }
    boolean search(Object x) throws InterruptedException {
      Node p = getHead();
      if (p == null) return false;
      //  (This could be made more compact, but for clarity of illustration,
      //  all of the cases that can arise are handled separately.)
      p.lock.acquire();              // Prime loop by acquiring first lock.
                                     //    (If the acquire fails due to
                                     //    interrupt, the method will throw
                                     //    InterruptedException now,
                                     //    so there is no need for any
                                     //    further cleanup.)
      for (;;) {
        if (x.equals(p.item)) {
          p.lock.release();          // release current before return
          return true;
        }
        else {
          Node nextp = p.next;
          if (nextp == null) {
            p.lock.release();       // release final lock that was held
            return false;
          }
          else {
            try {
              nextp.lock.acquire(); // get next lock before releasing current
            }
            catch (InterruptedException ex) {
              p.lock.release();    // also release current if acquire fails
              throw ex;
            }
            p.lock.release();      // release old lock now that new one held
            p = nextp;
          }
        }
      }
    }
    synchronized void add(Object x) { // simple prepend
      // The use of `synchronized'  here protects only head field.
      // The method does not need to wait out other traversers
      // who have already made it past head.
      head = new Node(x, head);
    }
 

// ... other similar traversal and update methods ... }

Version:

1.2

Author:

Doug Lea

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	inuse_ The lock status

Constructor Summary

Constructors

Constructor and Description
Mutex()

Method Summary

Modifier and Type	Method and Description
void	acquire() Acquire.
boolean	attempt(long msecs) Attempt boolean.
void	release() Release.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

inuse_

protected boolean inuse_

The lock status

Constructor Detail

Mutex

public Mutex()

Method Detail

acquire

public void acquire()
             throws InterruptedException

Acquire.

Throws:

InterruptedException - the interrupted exception

release

public void release()

Release.

attempt

public boolean attempt(long msecs)
                throws InterruptedException

Attempt boolean.

Parameters:

msecs - the msecs

Returns:

the boolean

Throws:

InterruptedException - the interrupted exception