< prev index next >

src/java.base/share/classes/java/util/concurrent/locks/AbstractOwnableSynchronizer.java

Print this page




  44  * appropriately maintained values to help control and monitor access
  45  * and provide diagnostics.
  46  *
  47  * @since 1.6
  48  * @author Doug Lea
  49  */
  50 public abstract class AbstractOwnableSynchronizer
  51     implements java.io.Serializable {
  52 
  53     /** Use serial ID even though all fields transient. */
  54     private static final long serialVersionUID = 3737899427754241961L;
  55 
  56     /**
  57      * Empty constructor for use by subclasses.
  58      */
  59     protected AbstractOwnableSynchronizer() { }
  60 
  61     /**
  62      * The current owner of exclusive mode synchronization.
  63      */
  64     private transient Thread exclusiveOwnerThread;
























  65 
  66     /**
  67      * Sets the thread that currently owns exclusive access.
  68      * A {@code null} argument indicates that no thread owns access.
  69      * This method does not otherwise impose any synchronization or
  70      * {@code volatile} field accesses.
  71      * @param thread the owner thread
  72      */
  73     protected final void setExclusiveOwnerThread(Thread thread) {
  74         exclusiveOwnerThread = thread;
  75     }
  76 
  77     /**
  78      * Returns the thread last set by {@code setExclusiveOwnerThread},
  79      * or {@code null} if never set.  This method does not otherwise
  80      * impose any synchronization or {@code volatile} field accesses.
  81      * @return the owner thread

  82      */
  83     protected final Thread getExclusiveOwnerThread() {
  84         return exclusiveOwnerThread;
  85     }
  86 }


  44  * appropriately maintained values to help control and monitor access
  45  * and provide diagnostics.
  46  *
  47  * @since 1.6
  48  * @author Doug Lea
  49  */
  50 public abstract class AbstractOwnableSynchronizer
  51     implements java.io.Serializable {
  52 
  53     /** Use serial ID even though all fields transient. */
  54     private static final long serialVersionUID = 3737899427754241961L;
  55 
  56     /**
  57      * Empty constructor for use by subclasses.
  58      */
  59     protected AbstractOwnableSynchronizer() { }
  60 
  61     /**
  62      * The current owner of exclusive mode synchronization.
  63      */
  64     private transient Object exclusiveOwner;
  65 
  66     /**
  67      * Sets the strand that currently owns exclusive access.
  68      * A {@code null} argument indicates that no strand owns access.
  69      * This method does not otherwise impose any synchronization or
  70      * {@code volatile} field accesses.
  71      * @param owner the owner thread or fiber
  72      */
  73     protected final void setExclusiveOwner(Object owner) {
  74         if (owner != null && !(owner instanceof Thread || owner instanceof Fiber))
  75             throw new IllegalArgumentException();
  76         exclusiveOwner = owner;
  77     }
  78 
  79     /**
  80      * Returns the strand last set by {@code setExclusiveOwnerStrand}
  81      * or {@code setExclusiveOwnerThread}, or {@code null} if never set.
  82      * This method does not otherwise impose any synchronization or {@code
  83      * volatile} field accesses.
  84      * @return the owner thread
  85      */
  86     protected final Object getExclusiveOwner() {
  87         return exclusiveOwner;
  88     }
  89 
  90     /**
  91      * Sets the thread that currently owns exclusive access.
  92      * A {@code null} argument indicates that no thread owns access.
  93      * This method does not otherwise impose any synchronization or
  94      * {@code volatile} field accesses.
  95      * @param thread the owner thread
  96      */
  97     protected final void setExclusiveOwnerThread(Thread thread) {
  98         exclusiveOwner = thread;
  99     }
 100 
 101     /**
 102      * Returns the thread last set by {@code setExclusiveOwnerThread},
 103      * or {@code null} if never set.  This method does not otherwise
 104      * impose any synchronization or {@code volatile} field accesses.
 105      * @return the owner thread
 106      * @throws ClassCastException if the synchronizer is owned by a Fiber
 107      */
 108     protected final Thread getExclusiveOwnerThread() {
 109         return (Thread) exclusiveOwner;
 110     }
 111 }
< prev index next >