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

AtomicReferenceArray

public class AtomicReferenceArray extends Object implements Serializable
An array of object references 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
param
The base class of elements held in this array

Fields Summary
private static final long
serialVersionUID
private static final Unsafe
unsafe
private static final int
base
private static final int
scale
private final Object[]
array
Constructors Summary
public AtomicReferenceArray(int length)
Create a new AtomicReferenceArray of given length.

param
length the length of the array

        array = new Object[length];
        // must perform at least one volatile write to conform to JMM
        if (length > 0) 
            unsafe.putObjectVolatile(array, rawIndex(0), null);
    
public AtomicReferenceArray(E[] array)
Create a new AtomicReferenceArray 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 Object[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
            E e = array[last];
            unsafe.putObjectVolatile(this.array, rawIndex(last), e);
        }
    
Methods Summary
public final booleancompareAndSet(int i, E expect, E 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.compareAndSwapObject(array, rawIndex(i), 
                                         expect, update);
    
public final Eget(int i)
Get the current value at position i.

param
i the index
return
the current value

        return (E) unsafe.getObjectVolatile(array, rawIndex(i));
    
public final EgetAndSet(int i, E 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) {
            E current = get(i);
            if (compareAndSet(i, current, newValue))
                return current;
        }
    
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, E newValue)
Set the element at position i to the given value.

param
i the index
param
newValue the new value

        unsafe.putObjectVolatile(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, E expect, E 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);