Package com.arjuna.ats.txoj

Class Lock

java.lang.Object
com.arjuna.ats.arjuna.StateManager
com.arjuna.ats.txoj.Lock
public class Lock extends StateManager
Instances of this class (or derived user classes) are used when trying to set a lock. The default implementation provides a single-write/multiple-reader policy. However, by overridding the appropriate methods, other, type-specific concurrency control locks can be implemented.
Since:
JTS 1.0.
Version:
$Id: Lock.java 2342 2006-03-30 13:06:17Z $
Author:
Mark Little (mark@arjuna.com)

  • Constructor Details

    • Lock

      public Lock()
      Create a new lock.

    • Lock

      public Lock(int lm)
      Create a new Lock object and initialise it. Mode is based upon argument. The value of BasicAction.Current determines the values of the remainder of the fields. If there is no action running the owner field is set to be the application uid created when the application starts.

    • Lock

      public Lock(Uid storeUid)
      This is used when re-initialising a Lock after retrieval from the object store.

  • Method Details

    • finalize

      public void finalize() throws Throwable
      General clean up as Lock is deleted.
      Overrides:
      finalize in class Object
      Throws:
      Throwable

    • getLockMode

      public final int getLockMode()
      Returns:
      the mode this lock is currently in, e.g., LockMode.READ.

    • getCurrentOwner

      public final Uid getCurrentOwner()
      Returns:
      the identity of the lock's current owner (the transaction id).

    • getAllOwners

      public final ActionHierarchy getAllOwners()
      Returns:
      the transaction hierarchy associated with this lock.

    • getCurrentStatus

      public final int getCurrentStatus()
      Returns:
      the lock's current status.

    • changeHierarchy

      public final void changeHierarchy(ActionHierarchy newOwner)
      Change the transaction hierarchy associated with the lock to that provided.

    • propagate

      public final void propagate()
      Propagate the lock.

    • modifiesObject

      public boolean modifiesObject()
      Does this lock imply a modification of the object it is applied to? For example, a READ lock would return false, but a WRITE lock would return true.
      Returns:
      true if this lock implies the object's state will be modified, false otherwise.

    • conflictsWith

      public boolean conflictsWith(Lock otherLock)
      Implementation of Lock conflict check. Returns TRUE if there is conflict FALSE otherwise. Does not take account of relationship in the atomic action hierarchy since this is a function of LockManager.
      Returns:
      true if this lock conflicts with the parameter, false otherwise.

    • equals

      public boolean equals(Object otherLock)
      Overrides Object.equals()
      Overrides:
      equals in class Object

    • equals

      public boolean equals(Lock otherLock)
      Are the two locks equal?
      Returns:
      true if the locks are equal, false otherwise.

    • toString

      public String toString()
      Overrides Object.toString()
      Overrides:
      toString in class Object

    • print

      public void print(PrintWriter strm)
      functions inherited from StateManager
      Overrides:
      print in class StateManager

    • restore_state

      public boolean restore_state(InputObjectState os, int ot)
      Carefully restore the state of a Lock.
      Overrides:
      restore_state in class StateManager
      Returns:
      true if successful, false otherwise.

    • save_state

      public boolean save_state(OutputObjectState os, int ot)
      Save the state of a lock object.
      Overrides:
      save_state in class StateManager
      Returns:
      true if successful, false otherwise.

    • type

      public String type()
      Overrides StateManager.type()
      Overrides:
      type in class StateManager

    • getLink

      protected Lock getLink()
      Get the next lock in the chain.

    • setLink

      protected void setLink(Lock pointTo)
      Set the next lock in the chain.