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

AtomicLongArray

public class AtomicLongArray extends Object implements Serializable
A long 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 long[]
array
Constructors Summary
public AtomicLongArray(int length)
Create a new AtomicLongArray of given length.

param
length the length of the array

        array = new long[length];
        // must perform at least one volatile write to conform to JMM
        if (length > 0) 
            unsafe.putLongVolatile(array, rawIndex(0), 0);
    
public AtomicLongArray(long[] array)
Create a new AtomicLongArray 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 long[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.putLongVolatile(this.array, rawIndex(last), array[last]);
        }
    
Methods Summary
public longaddAndGet(int i, long 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) {
            long current = get(i);
            long next = current + delta;
            if (compareAndSet(i, current, next))
                return next;
        }
    
public final booleancompareAndSet(int i, long expect, long 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.compareAndSwapLong(array, rawIndex(i), 
                                         expect, update);
    
public final longdecrementAndGet(int i)
Atomically decrement the element at index i.

param
i the index
return
the updated value;

        while (true) {
            long current = get(i);
            long next = current - 1;
            if (compareAndSet(i, current, next))
                return next;
        }
    
public final longget(int i)
Get the current value at position i.

param
i the index
return
the current value

        return unsafe.getLongVolatile(array, rawIndex(i));
    
public final longgetAndAdd(int i, long 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) {
            long current = get(i);
            long next = current + delta;
            if (compareAndSet(i, current, next))
                return current;
        }
    
public final longgetAndDecrement(int i)
Atomically decrement by one the element at index i.

param
i the index
return
the previous value;

        while (true) {
            long current = get(i);
            long next = current - 1;
            if (compareAndSet(i, current, next))
                return current;
        }
    
public final longgetAndIncrement(int i)
Atomically increment by one the element at index i.

param
i the index
return
the previous value;

        while (true) {
            long current = get(i);
            long next = current + 1;
            if (compareAndSet(i, current, next))
                return current;
        }
    
public final longgetAndSet(int i, long 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) {
            long current = get(i);
            if (compareAndSet(i, current, newValue))
                return current;
        }
    
public final longincrementAndGet(int i)
Atomically increment the element at index i.

param
i the index
return
the updated value;

        while (true) {
            long current = get(i);
            long 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, long newValue)
Set the element at position i to the given value.

param
i the index
param
newValue the new value

        unsafe.putLongVolatile(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, long expect, long 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);