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

   1 *java.util.concurrent.atomic.AtomicMarkableReference* *AtomicMarkableReference*
   2
   3 public class AtomicMarkableReference
   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 new A
  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 An AtomicMarkableReference maintains 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 *java.util.concurrent.atomic.AtomicMarkableReference(V,boolean)*
  35
  36 public AtomicMarkableReference(
  37   java.lang.Object initialRef,
  38   boolean initialMark)
  39
  40 Creates a new AtomicMarkableReference with the given initial values.
  41
  42     initialRef - the initial reference
  43     initialMark - the initial mark
  44
  45 *java.util.concurrent.atomic.AtomicMarkableReference.attemptMark(V,boolean)*
  46
  47 public boolean attemptMark(
  48   java.lang.Object expectedReference,
  49   boolean newMark)
  50
  51 Atomically sets the value of the mark to the given update value if the current
  52 reference is == to the expected reference. Any given invocation of this
  53 operation may fail (return false) spuriously, but repeated invocation when the
  54 current value holds the expected value and no other thread is also attempting
  55 to set the value will eventually succeed.
  56
  57     expectedReference - the expected value of the reference
  58     newMark - the new value for the mark
  59
  60     Returns: true if successful
  61 *java.util.concurrent.atomic.AtomicMarkableReference.compareAndSet(V,V,boolean,boolean)*
  62
  63 public boolean compareAndSet(
  64   java.lang.Object expectedReference,
  65   java.lang.Object newReference,
  66   boolean expectedMark,
  67   boolean newMark)
  68
  69 Atomically sets the value of both the reference and mark to the given update
  70 values if the current reference is == to the expected reference and the current
  71 mark is equal to the expected mark.
  72
  73     expectedReference - the expected value of the reference
  74     newReference - the new value for the reference
  75     expectedMark - the expected value of the mark
  76     newMark - the new value for the mark
  77
  78     Returns: true if successful
  79 *java.util.concurrent.atomic.AtomicMarkableReference.get(boolean[])*
  80
  81 public |java.lang.Object| get(boolean[] markHolder)
  82
  83 Returns the current values of both the reference and the mark. Typical usage is
  84 boolean[1] holder; ref = v.get(holder); .
  85
  86     markHolder - an array of size of at least one. On return, markholder[0] will hold the value
  87        of the mark.
  88
  89     Returns: the current value of the reference
  90 *java.util.concurrent.atomic.AtomicMarkableReference.getReference()*
  91
  92 public |java.lang.Object| getReference()
  93
  94 Returns the current value of the reference.
  95
  96
  97     Returns: the current value of the reference
  98 *java.util.concurrent.atomic.AtomicMarkableReference.isMarked()*
  99
 100 public boolean isMarked()
 101
 102 Returns the current value of the mark.
 103
 104
 105     Returns: the current value of the mark
 106 *java.util.concurrent.atomic.AtomicMarkableReference.set(V,boolean)*
 107
 108 public void set(
 109   java.lang.Object newReference,
 110   boolean newMark)
 111
 112 Unconditionally sets the value of both the reference and mark.
 113
 114     newReference - the new value for the reference
 115     newMark - the new value for the mark
 116
 117 *java.util.concurrent.atomic.AtomicMarkableReference.weakCompareAndSet(V,V,boolean,boolean)*
 118
 119 public boolean weakCompareAndSet(
 120   java.lang.Object expectedReference,
 121   java.lang.Object newReference,
 122   boolean expectedMark,
 123   boolean newMark)
 124
 125 Atomically sets the value of both the reference and mark to the given update
 126 values if the current reference is == to the expected reference and the current
 127 mark is equal to the expected mark. Any given invocation of this operation may
 128 fail (return false) spuriously, but repeated invocation when the current value
 129 holds the expected value and no other thread is also attempting to set the
 130 value will eventually succeed.
 131
 132     expectedReference - the expected value of the reference
 133     newReference - the new value for the reference
 134     expectedMark - the expected value of the mark
 135     newMark - the new value for the mark
 136
 137     Returns: true if successful
 138