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

   1 *java.util.concurrent.atomic.AtomicIntegerArray* *AtomicIntegerArray* Anintarray
   2
   3 public class AtomicIntegerArray
   4   extends    |java.lang.Object|
   5   implements |java.io.Serializable|
   6
   7 |java.util.concurrent.atomic.AtomicIntegerArray_Description|
   8 |java.util.concurrent.atomic.AtomicIntegerArray_Fields|
   9 |java.util.concurrent.atomic.AtomicIntegerArray_Constructors|
  10 |java.util.concurrent.atomic.AtomicIntegerArray_Methods|
  11
  12 ================================================================================
  13
  14 *java.util.concurrent.atomic.AtomicIntegerArray_Constructors*
  15 |java.util.concurrent.atomic.AtomicIntegerArray(int)|Creates a new AtomicIntege
  16 |java.util.concurrent.atomic.AtomicIntegerArray(int[])|Creates a new AtomicInte
  17
  18 *java.util.concurrent.atomic.AtomicIntegerArray_Methods*
  19 |java.util.concurrent.atomic.AtomicIntegerArray.addAndGet(int,int)|Atomically a
  20 |java.util.concurrent.atomic.AtomicIntegerArray.compareAndSet(int,int,int)|Atom
  21 |java.util.concurrent.atomic.AtomicIntegerArray.decrementAndGet(int)|Atomically
  22 |java.util.concurrent.atomic.AtomicIntegerArray.get(int)|Gets the current value
  23 |java.util.concurrent.atomic.AtomicIntegerArray.getAndAdd(int,int)|Atomically a
  24 |java.util.concurrent.atomic.AtomicIntegerArray.getAndDecrement(int)|Atomically
  25 |java.util.concurrent.atomic.AtomicIntegerArray.getAndIncrement(int)|Atomically
  26 |java.util.concurrent.atomic.AtomicIntegerArray.getAndSet(int,int)|Atomically s
  27 |java.util.concurrent.atomic.AtomicIntegerArray.incrementAndGet(int)|Atomically
  28 |java.util.concurrent.atomic.AtomicIntegerArray.lazySet(int,int)|Eventually set
  29 |java.util.concurrent.atomic.AtomicIntegerArray.length()|Returns the length of
  30 |java.util.concurrent.atomic.AtomicIntegerArray.set(int,int)|Sets the element a
  31 |java.util.concurrent.atomic.AtomicIntegerArray.toString()|Returns the String r
  32 |java.util.concurrent.atomic.AtomicIntegerArray.weakCompareAndSet(int,int,int)|
  33
  34 *java.util.concurrent.atomic.AtomicIntegerArray_Description*
  35
  36 Anintarray in which elements may be updated atomically. See the
  37 (|java.util.concurrent.atomic|) package specification for description of the
  38 properties of atomic variables.
  39
  40
  41
  42 *java.util.concurrent.atomic.AtomicIntegerArray(int)*
  43
  44 public AtomicIntegerArray(int length)
  45
  46 Creates a new AtomicIntegerArray of given length.
  47
  48     length - the length of the array
  49
  50 *java.util.concurrent.atomic.AtomicIntegerArray(int[])*
  51
  52 public AtomicIntegerArray(int[] array)
  53
  54 Creates a new AtomicIntegerArray with the same length as, and all elements
  55 copied from, the given array.
  56
  57     array - the array to copy elements from
  58
  59 *java.util.concurrent.atomic.AtomicIntegerArray.addAndGet(int,int)*
  60
  61 public final int addAndGet(
  62   int i,
  63   int delta)
  64
  65 Atomically adds the given value to the element at indexi.
  66
  67
  68     i - the index
  69     delta - the value to add
  70
  71     Returns: the updated value
  72
  73 *java.util.concurrent.atomic.AtomicIntegerArray.compareAndSet(int,int,int)*
  74
  75 public final boolean compareAndSet(
  76   int i,
  77   int expect,
  78   int update)
  79
  80 Atomically sets the element at positionito the given updated value if the
  81 current value==the expected value.
  82
  83
  84     i - the index
  85     expect - the expected value
  86     update - the new value
  87
  88     Returns: true if successful. False return indicates that the actual value was not equal
  89              to the expected value.
  90
  91 *java.util.concurrent.atomic.AtomicIntegerArray.decrementAndGet(int)*
  92
  93 public final int decrementAndGet(int i)
  94
  95 Atomically decrements by one the element at indexi.
  96
  97
  98     i - the index
  99
 100     Returns: the updated value
 101
 102 *java.util.concurrent.atomic.AtomicIntegerArray.get(int)*
 103
 104 public final int get(int i)
 105
 106 Gets the current value at positioni.
 107
 108
 109     i - the index
 110
 111     Returns: the current value
 112
 113 *java.util.concurrent.atomic.AtomicIntegerArray.getAndAdd(int,int)*
 114
 115 public final int getAndAdd(
 116   int i,
 117   int delta)
 118
 119 Atomically adds the given value to the element at indexi.
 120
 121
 122     i - the index
 123     delta - the value to add
 124
 125     Returns: the previous value
 126
 127 *java.util.concurrent.atomic.AtomicIntegerArray.getAndDecrement(int)*
 128
 129 public final int getAndDecrement(int i)
 130
 131 Atomically decrements by one the element at indexi.
 132
 133
 134     i - the index
 135
 136     Returns: the previous value
 137
 138 *java.util.concurrent.atomic.AtomicIntegerArray.getAndIncrement(int)*
 139
 140 public final int getAndIncrement(int i)
 141
 142 Atomically increments by one the element at indexi.
 143
 144
 145     i - the index
 146
 147     Returns: the previous value
 148
 149 *java.util.concurrent.atomic.AtomicIntegerArray.getAndSet(int,int)*
 150
 151 public final int getAndSet(
 152   int i,
 153   int newValue)
 154
 155 Atomically sets the element at positionito the given value and returns the old
 156 value.
 157
 158
 159     i - the index
 160     newValue - the new value
 161
 162     Returns: the previous value
 163
 164 *java.util.concurrent.atomic.AtomicIntegerArray.incrementAndGet(int)*
 165
 166 public final int incrementAndGet(int i)
 167
 168 Atomically increments by one the element at indexi.
 169
 170
 171     i - the index
 172
 173     Returns: the updated value
 174
 175 *java.util.concurrent.atomic.AtomicIntegerArray.lazySet(int,int)*
 176
 177 public final void lazySet(
 178   int i,
 179   int newValue)
 180
 181 Eventually sets the element at positionito the given value.
 182
 183
 184     i - the index
 185     newValue - the new value
 186
 187 *java.util.concurrent.atomic.AtomicIntegerArray.length()*
 188
 189 public final int length()
 190
 191 Returns the length of the array.
 192
 193
 194
 195     Returns: the length of the array
 196
 197 *java.util.concurrent.atomic.AtomicIntegerArray.set(int,int)*
 198
 199 public final void set(
 200   int i,
 201   int newValue)
 202
 203 Sets the element at positionito the given value.
 204
 205
 206     i - the index
 207     newValue - the new value
 208
 209 *java.util.concurrent.atomic.AtomicIntegerArray.toString()*
 210
 211 public |java.lang.String| toString()
 212
 213 Returns the String representation of the current values of array.
 214
 215
 216
 217     Returns: the String representation of the current values of array.
 218
 219 *java.util.concurrent.atomic.AtomicIntegerArray.weakCompareAndSet(int,int,int)*
 220
 221 public final boolean weakCompareAndSet(
 222   int i,
 223   int expect,
 224   int update)
 225
 226 Atomically sets the element at positionito the given updated value if the
 227 current value==the expected value.
 228
 229 May fail spuriously and does not provide ordering guarantees, so is only rarely
 230 an appropriate alternative tocompareAndSet.
 231
 232
 233     i - the index
 234     expect - the expected value
 235     update - the new value
 236
 237     Returns: true if successful.
 238
 239