File	Doc	Category	Size	Date	Package
AtomicIntegerArray.java	API Doc	Java SE 6 API	7580	Tue Jun 10 00:25:56 BST 2008	java.util.concurrent.atomic

AtomicIntegerArray

• java.lang.Object

Fields Summary
private static final long	serialVersionUID
private static final Unsafe	unsafe
private static final int	base
private static final int	scale
private final int[]	array

Constructors Summary
public AtomicIntegerArray(int length) Creates a new AtomicIntegerArray of given length. param length the length of the array array = new int[length]; // must perform at least one volatile write to conform to JMM if (length > 0) unsafe.putIntVolatile(array, rawIndex(0), 0);
public AtomicIntegerArray(int[] array) Creates a new AtomicIntegerArray with the same length as, and all elements copied from, the given array. param array the array to copy elements from throws NullPointerException if array is null if (array == null) throw new NullPointerException(); int length = array.length; this.array = new int[length]; if (length > 0) { int last = length-1; for (int i = 0; i < last; ++i) this.array[i] = array[i]; // Do the last write as volatile unsafe.putIntVolatile(this.array, rawIndex(last), array[last]); }

Methods Summary
public final int	addAndGet(int i, int delta) Atomically adds the given value to the element at index {@code i}. param i the index param delta the value to add return the updated value while (true) { int current = get(i); int next = current + delta; if (compareAndSet(i, current, next)) return next; }
public final boolean	compareAndSet(int i, int expect, int update) Atomically sets the element at position {@code i} to the given updated value if the current value {@code ==} the expected value. param i the index param expect the expected value param update the new value return true if successful. False return indicates that the actual value was not equal to the expected value. return unsafe.compareAndSwapInt(array, rawIndex(i), expect, update);
public final int	decrementAndGet(int i) Atomically decrements by one the element at index {@code i}. param i the index return the updated value while (true) { int current = get(i); int next = current - 1; if (compareAndSet(i, current, next)) return next; }
public final int	get(int i) Gets the current value at position {@code i}. param i the index return the current value return unsafe.getIntVolatile(array, rawIndex(i));
public final int	getAndAdd(int i, int delta) Atomically adds the given value to the element at index {@code i}. param i the index param delta the value to add return the previous value while (true) { int current = get(i); int next = current + delta; if (compareAndSet(i, current, next)) return current; }
public final int	getAndDecrement(int i) Atomically decrements by one the element at index {@code i}. param i the index return the previous value while (true) { int current = get(i); int next = current - 1; if (compareAndSet(i, current, next)) return current; }
public final int	getAndIncrement(int i) Atomically increments by one the element at index {@code i}. param i the index return the previous value while (true) { int current = get(i); int next = current + 1; if (compareAndSet(i, current, next)) return current; }
public final int	getAndSet(int i, int newValue) Atomically sets the element at position {@code i} to the given value and returns the old value. param i the index param newValue the new value return the previous value while (true) { int current = get(i); if (compareAndSet(i, current, newValue)) return current; }
public final int	incrementAndGet(int i) Atomically increments by one the element at index {@code i}. param i the index return the updated value while (true) { int current = get(i); int next = current + 1; if (compareAndSet(i, current, next)) return next; }
public final void	lazySet(int i, int newValue) Eventually sets the element at position {@code i} to the given value. param i the index param newValue the new value since 1.6 unsafe.putOrderedInt(array, rawIndex(i), newValue);
public final int	length() Returns the length of the array. return the length of the array return array.length;
private long	rawIndex(int i) if (i < 0 || i >= array.length) throw new IndexOutOfBoundsException("index " + i); return base + i * scale;
public final void	set(int i, int newValue) Sets the element at position {@code i} to the given value. param i the index param newValue the new value unsafe.putIntVolatile(array, rawIndex(i), newValue);
public java.lang.String	toString() Returns the String representation of the current values of array. return the String representation of the current values of array. if (array.length > 0) // force volatile read get(0); return Arrays.toString(array);
public final boolean	weakCompareAndSet(int i, int expect, int update) Atomically sets the element at position {@code i} to the given updated value if the current value {@code ==} the expected value. May fail spuriously and does not provide ordering guarantees, so is only rarely an appropriate alternative to {@code compareAndSet}. param i the index param expect the expected value param update the new value return true if successful. return compareAndSet(i, expect, update);