src/share/classes/java/util/concurrent/atomic/AtomicIntegerArray.java

Print this page




 128     /**
 129      * Eventually sets the element at position {@code i} to the given value.
 130      *
 131      * @param i the index
 132      * @param newValue the new value
 133      * @since 1.6
 134      */
 135     public final void lazySet(int i, int newValue) {
 136         unsafe.putOrderedInt(array, checkedByteOffset(i), newValue);
 137     }
 138 
 139     /**
 140      * Atomically sets the element at position {@code i} to the given
 141      * value and returns the old value.
 142      *
 143      * @param i the index
 144      * @param newValue the new value
 145      * @return the previous value
 146      */
 147     public final int getAndSet(int i, int newValue) {
 148         long offset = checkedByteOffset(i);
 149         while (true) {
 150             int current = getRaw(offset);
 151             if (compareAndSetRaw(offset, current, newValue))
 152                 return current;
 153         }
 154     }
 155 
 156     /**
 157      * Atomically sets the element at position {@code i} to the given
 158      * updated value if the current value {@code ==} the expected value.
 159      *
 160      * @param i the index
 161      * @param expect the expected value
 162      * @param update the new value
 163      * @return true if successful. False return indicates that
 164      * the actual value was not equal to the expected value.
 165      */
 166     public final boolean compareAndSet(int i, int expect, int update) {
 167         return compareAndSetRaw(checkedByteOffset(i), expect, update);
 168     }
 169 
 170     private boolean compareAndSetRaw(long offset, int expect, int update) {
 171         return unsafe.compareAndSwapInt(array, offset, expect, update);
 172     }
 173 
 174     /**
 175      * Atomically sets the element at position {@code i} to the given
 176      * updated value if the current value {@code ==} the expected value.
 177      *
 178      * <p>May <a href="package-summary.html#Spurious">fail spuriously</a>
 179      * and does not provide ordering guarantees, so is only rarely an
 180      * appropriate alternative to {@code compareAndSet}.
 181      *
 182      * @param i the index
 183      * @param expect the expected value
 184      * @param update the new value
 185      * @return true if successful.
 186      */
 187     public final boolean weakCompareAndSet(int i, int expect, int update) {
 188         return compareAndSet(i, expect, update);
 189     }
 190 
 191     /**
 192      * Atomically increments by one the element at index {@code i}.
 193      *
 194      * @param i the index
 195      * @return the previous value
 196      */
 197     public final int getAndIncrement(int i) {
 198         return getAndAdd(i, 1);
 199     }
 200 
 201     /**
 202      * Atomically decrements by one the element at index {@code i}.
 203      *
 204      * @param i the index
 205      * @return the previous value
 206      */
 207     public final int getAndDecrement(int i) {
 208         return getAndAdd(i, -1);
 209     }
 210 
 211     /**
 212      * Atomically adds the given value to the element at index {@code i}.
 213      *
 214      * @param i the index
 215      * @param delta the value to add
 216      * @return the previous value
 217      */
 218     public final int getAndAdd(int i, int delta) {
 219         long offset = checkedByteOffset(i);
 220         while (true) {
 221             int current = getRaw(offset);
 222             if (compareAndSetRaw(offset, current, current + delta))
 223                 return current;
 224         }
 225     }
 226 
 227     /**
 228      * Atomically increments by one the element at index {@code i}.
 229      *
 230      * @param i the index
 231      * @return the updated value
 232      */
 233     public final int incrementAndGet(int i) {
 234         return addAndGet(i, 1);
 235     }
 236 
 237     /**
 238      * Atomically decrements by one the element at index {@code i}.
 239      *
 240      * @param i the index
 241      * @return the updated value
 242      */
 243     public final int decrementAndGet(int i) {
 244         return addAndGet(i, -1);
 245     }
 246 
 247     /**
 248      * Atomically adds the given value to the element at index {@code i}.
 249      *
 250      * @param i the index
 251      * @param delta the value to add
 252      * @return the updated value
 253      */
 254     public final int addAndGet(int i, int delta) {
 255         long offset = checkedByteOffset(i);
 256         while (true) {
 257             int current = getRaw(offset);
 258             int next = current + delta;
 259             if (compareAndSetRaw(offset, current, next))
 260                 return next;
 261         }
 262     }
 263 
 264     /**
 265      * Returns the String representation of the current values of array.
 266      * @return the String representation of the current values of array
 267      */
 268     public String toString() {
 269         int iMax = array.length - 1;
 270         if (iMax == -1)
 271             return "[]";
 272 
 273         StringBuilder b = new StringBuilder();
 274         b.append('[');
 275         for (int i = 0; ; i++) {
 276             b.append(getRaw(byteOffset(i)));
 277             if (i == iMax)
 278                 return b.append(']').toString();
 279             b.append(',').append(' ');
 280         }
 281     }
 282 


 128     /**
 129      * Eventually sets the element at position {@code i} to the given value.
 130      *
 131      * @param i the index
 132      * @param newValue the new value
 133      * @since 1.6
 134      */
 135     public final void lazySet(int i, int newValue) {
 136         unsafe.putOrderedInt(array, checkedByteOffset(i), newValue);
 137     }
 138 
 139     /**
 140      * Atomically sets the element at position {@code i} to the given
 141      * value and returns the old value.
 142      *
 143      * @param i the index
 144      * @param newValue the new value
 145      * @return the previous value
 146      */
 147     public final int getAndSet(int i, int newValue) {
 148         return unsafe.getAndSetInt(array, checkedByteOffset(i), newValue);




 149     }

 150 
 151     /**
 152      * Atomically sets the element at position {@code i} to the given
 153      * updated value if the current value {@code ==} the expected value.
 154      *
 155      * @param i the index
 156      * @param expect the expected value
 157      * @param update the new value
 158      * @return true if successful. False return indicates that
 159      * the actual value was not equal to the expected value.
 160      */
 161     public final boolean compareAndSet(int i, int expect, int update) {
 162         return compareAndSetRaw(checkedByteOffset(i), expect, update);
 163     }
 164 
 165     private boolean compareAndSetRaw(long offset, int expect, int update) {
 166         return unsafe.compareAndSwapInt(array, offset, expect, update);
 167     }
 168 
 169     /**
 170      * Atomically sets the element at position {@code i} to the given
 171      * updated value if the current value {@code ==} the expected value.
 172      *
 173      * <p>May <a href="package-summary.html#Spurious">fail spuriously</a>
 174      * and does not provide ordering guarantees, so is only rarely an
 175      * appropriate alternative to {@code compareAndSet}.
 176      *
 177      * @param i the index
 178      * @param expect the expected value
 179      * @param update the new value
 180      * @return true if successful
 181      */
 182     public final boolean weakCompareAndSet(int i, int expect, int update) {
 183         return compareAndSet(i, expect, update);
 184     }
 185 
 186     /**
 187      * Atomically increments by one the element at index {@code i}.
 188      *
 189      * @param i the index
 190      * @return the previous value
 191      */
 192     public final int getAndIncrement(int i) {
 193         return getAndAdd(i, 1);
 194     }
 195 
 196     /**
 197      * Atomically decrements by one the element at index {@code i}.
 198      *
 199      * @param i the index
 200      * @return the previous value
 201      */
 202     public final int getAndDecrement(int i) {
 203         return getAndAdd(i, -1);
 204     }
 205 
 206     /**
 207      * Atomically adds the given value to the element at index {@code i}.
 208      *
 209      * @param i the index
 210      * @param delta the value to add
 211      * @return the previous value
 212      */
 213     public final int getAndAdd(int i, int delta) {
 214         return unsafe.getAndAddInt(array, checkedByteOffset(i), delta);




 215     }

 216 
 217     /**
 218      * Atomically increments by one the element at index {@code i}.
 219      *
 220      * @param i the index
 221      * @return the updated value
 222      */
 223     public final int incrementAndGet(int i) {
 224         return getAndAdd(i, 1) + 1;
 225     }
 226 
 227     /**
 228      * Atomically decrements by one the element at index {@code i}.
 229      *
 230      * @param i the index
 231      * @return the updated value
 232      */
 233     public final int decrementAndGet(int i) {
 234         return getAndAdd(i, -1) - 1;
 235     }
 236 
 237     /**
 238      * Atomically adds the given value to the element at index {@code i}.
 239      *
 240      * @param i the index
 241      * @param delta the value to add
 242      * @return the updated value
 243      */
 244     public final int addAndGet(int i, int delta) {
 245         return getAndAdd(i, delta) + delta;





 246     }

 247 
 248     /**
 249      * Returns the String representation of the current values of array.
 250      * @return the String representation of the current values of array
 251      */
 252     public String toString() {
 253         int iMax = array.length - 1;
 254         if (iMax == -1)
 255             return "[]";
 256 
 257         StringBuilder b = new StringBuilder();
 258         b.append('[');
 259         for (int i = 0; ; i++) {
 260             b.append(getRaw(byteOffset(i)));
 261             if (i == iMax)
 262                 return b.append(']').toString();
 263             b.append(',').append(' ');
 264         }
 265     }
 266