sample/java.util.concurrent.atomic.AtomicMarkableReference.txt

   1 *java.util.concurrent.atomic.AtomicMarkableReference* *AtomicMarkableReference*
   2
   3 public class AtomicMarkableReference<V>
   4   extends    |java.lang.Object|
   5
   6 |java.util.concurrent.atomic.AtomicMarkableReference_Description|
   7 |java.util.concurrent.atomic.AtomicMarkableReference_Fields|
   8 |java.util.concurrent.atomic.AtomicMarkableReference_Constructors|
   9 |java.util.concurrent.atomic.AtomicMarkableReference_Methods|
  10
  11 ================================================================================
  12
  13 *java.util.concurrent.atomic.AtomicMarkableReference_Constructors*
  14 |java.util.concurrent.atomic.AtomicMarkableReference(V,boolean)|Creates a newAt
  15
  16 *java.util.concurrent.atomic.AtomicMarkableReference_Methods*
  17 |java.util.concurrent.atomic.AtomicMarkableReference.attemptMark(V,boolean)|Ato
  18 |java.util.concurrent.atomic.AtomicMarkableReference.compareAndSet(V,V,boolean,boolean)|
  19 |java.util.concurrent.atomic.AtomicMarkableReference.get(boolean[])|Returns the
  20 |java.util.concurrent.atomic.AtomicMarkableReference.getReference()|Returns the
  21 |java.util.concurrent.atomic.AtomicMarkableReference.isMarked()|Returns the cur
  22 |java.util.concurrent.atomic.AtomicMarkableReference.set(V,boolean)|Uncondition
  23 |java.util.concurrent.atomic.AtomicMarkableReference.weakCompareAndSet(V,V,boolean,boolean)|
  24
  25 *java.util.concurrent.atomic.AtomicMarkableReference_Description*
  26
  27 AnAtomicMarkableReferencemaintains an object reference along with a mark bit,
  28 that can be updated atomically.
  29
  30 Implementation note. This implementation maintains markable references by
  31 creating internal objects representing "boxed" [reference, boolean] pairs.
  32
  33
  34
  35 *java.util.concurrent.atomic.AtomicMarkableReference(V,boolean)*
  36
  37 public AtomicMarkableReference(
  38   V initialRef,
  39   boolean initialMark)
  40
  41 Creates a newAtomicMarkableReferencewith the given initial values.
  42
  43     initialRef - the initial reference
  44     initialMark - the initial mark
  45
  46 *java.util.concurrent.atomic.AtomicMarkableReference.attemptMark(V,boolean)*
  47
  48 public boolean attemptMark(
  49   V expectedReference,
  50   boolean newMark)
  51
  52 Atomically sets the value of the mark to the given update value if the current
  53 reference is==to the expected reference. Any given invocation of this operation
  54 may fail (returnfalse) spuriously, but repeated invocation when the current
  55 value holds the expected value and no other thread is also attempting to set
  56 the value will eventually succeed.
  57
  58
  59     expectedReference - the expected value of the reference
  60     newMark - the new value for the mark
  61
  62     Returns: true if successful
  63
  64 *java.util.concurrent.atomic.AtomicMarkableReference.compareAndSet(V,V,boolean,boolean)*
  65
  66 public boolean compareAndSet(
  67   V expectedReference,
  68   V newReference,
  69   boolean expectedMark,
  70   boolean newMark)
  71
  72 Atomically sets the value of both the reference and mark to the given update
  73 values if the current reference is==to the expected reference and the current
  74 mark is equal to the expected mark.
  75
  76
  77     expectedReference - the expected value of the reference
  78     newReference - the new value for the reference
  79     expectedMark - the expected value of the mark
  80     newMark - the new value for the mark
  81
  82     Returns: true if successful
  83
  84 *java.util.concurrent.atomic.AtomicMarkableReference.get(boolean[])*
  85
  86 public |V| get(boolean[] markHolder)
  87
  88 Returns the current values of both the reference and the mark. Typical usage
  89 isboolean[1] holder; ref = v.get(holder);.
  90
  91
  92     markHolder - an array of size of at least one. On return, {@code markholder[0]} will hold
  93        the value of the mark.
  94
  95     Returns: the current value of the reference
  96
  97 *java.util.concurrent.atomic.AtomicMarkableReference.getReference()*
  98
  99 public |V| getReference()
 100
 101 Returns the current value of the reference.
 102
 103
 104
 105     Returns: the current value of the reference
 106
 107 *java.util.concurrent.atomic.AtomicMarkableReference.isMarked()*
 108
 109 public boolean isMarked()
 110
 111 Returns the current value of the mark.
 112
 113
 114
 115     Returns: the current value of the mark
 116
 117 *java.util.concurrent.atomic.AtomicMarkableReference.set(V,boolean)*
 118
 119 public void set(
 120   V newReference,
 121   boolean newMark)
 122
 123 Unconditionally sets the value of both the reference and mark.
 124
 125
 126     newReference - the new value for the reference
 127     newMark - the new value for the mark
 128
 129 *java.util.concurrent.atomic.AtomicMarkableReference.weakCompareAndSet(V,V,boolean,boolean)*
 130
 131 public boolean weakCompareAndSet(
 132   V expectedReference,
 133   V newReference,
 134   boolean expectedMark,
 135   boolean newMark)
 136
 137 Atomically sets the value of both the reference and mark to the given update
 138 values if the current reference is==to the expected reference and the current
 139 mark is equal to the expected mark.
 140
 141 May fail spuriously and does not provide ordering guarantees, so is only rarely
 142 an appropriate alternative tocompareAndSet.
 143
 144
 145     expectedReference - the expected value of the reference
 146     newReference - the new value for the reference
 147     expectedMark - the expected value of the mark
 148     newMark - the new value for the mark
 149
 150     Returns: true if successful
 151
 152