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 |