FileDocCategorySizeDatePackage
AtomicIntegerArray.javaAPI DocJava SE 5 API7053Fri Aug 26 14:57:26 BST 2005java.util.concurrent.atomic

AtomicIntegerArray

public class AtomicIntegerArray extends Object implements Serializable
An int array in which elements may be updated atomically. See the {@link java.util.concurrent.atomic} package specification for description of the properties of atomic variables.
since
1.5
author
Doug Lea

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)
Create 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)
Create 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 intaddAndGet(int i, int delta)
Atomically add the given value to element at index 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 booleancompareAndSet(int i, int expect, int update)
Atomically set the value to the given updated value if the current value == 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 intdecrementAndGet(int i)
Atomically decrement by one the element at index 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 intget(int i)
Get the current value at position i.

param
i the index
return
the current value

        return unsafe.getIntVolatile(array, rawIndex(i));
    
public final intgetAndAdd(int i, int delta)
Atomically add the given value to element at index 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 intgetAndDecrement(int i)
Atomically decrement by one the element at index 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 intgetAndIncrement(int i)
Atomically increment by one the element at index 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 intgetAndSet(int i, int newValue)
Set the element at position i to the given value and return 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 intincrementAndGet(int i)
Atomically increment by one the element at index 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 intlength()
Returns the length of the array.

return
the length of the array

        return array.length;
    
private longrawIndex(int i)


        
        if (i < 0 || i >= array.length)
            throw new IndexOutOfBoundsException("index " + i);
        return base + i * scale;
    
public final voidset(int i, int newValue)
Set the element at position i to the given value.

param
i the index
param
newValue the new value

        unsafe.putIntVolatile(array, rawIndex(i), newValue);
    
public java.lang.StringtoString()
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 booleanweakCompareAndSet(int i, int expect, int update)
Atomically set the value to the given updated value if the current value == the expected value. May fail spuriously.

param
i the index
param
expect the expected value
param
update the new value
return
true if successful.

        return compareAndSet(i, expect, update);