- Java Concurrency Utilities - java.util.concurrent
- Java BlockingQueue
- Java ExecutorService
- Java Callable
- Java Future
- Java Fork and Join using ForkJoinPool
AtomicReferenceArray in the
java.util.concurrent.atomic package is an array
of object references which can be updated atomically. The
AtomicReferenceArray class also
supports compare-and-swap functionality.
Creating an AtomicReferenceArray
You can create an
AtomicReferenceArray using one of its two constructors.
The first constructor takes an
int as parameter. This
int specifies the length of the
AtomicReferenceArray to create, meaning how many elements it should have space for. Here is a Java
example of creating an
AtomicReferenceArray using this constructor:
AtomicReferenceArray array = new AtomicReferenceArray(10);
This example creates a
AtomicReferenceArray with a capacity of 10 (it has space for
10 object references as elements).
The second constructor takes a
E array as parameter, where E is the type (class) of the object references.
AtomicReferenceArray created using this constructor will have the same capacity as the array
parameter, and all elements from the array parameter will be copied into the
Here is a Java example of creating an
using this constructor:
Object source = new Object; source = "Some string"; AtomicReferenceArray array = new AtomicReferenceArray(source);
This example first creates a
Object array and sets a value into the element with index 5.
Then it creates an
AtomicReferenceArray with the
Object array as parameter.
You can also set a generic type for the
AtomicReferenceArray. Here is the example from above,
where the generic type is set to
String source = new String; source = "Some string"; AtomicReferenceArray<String> array = new AtomicReferenceArray<String>(source);
get() method returns the value of the element with the given index. The index is passed
as parameter to the
get() method. Here is an example:
Object element = array.get(5);
AtomicReferenceArray has a generic type, the
get() method returns objects of
that type. For instance, if the generic type is
String, then you can call
String element = array.get(5);
Notice that no casting to
String is necessary.
set() method sets the value of an element with a specific index. The index and value is passed
as parameters to the
set() method. Here is a
array.set(5, "another object");
The first parameter is the index of the element to set.
The second parameter is the value to set for the element. If the
AtomicReferenceArray has a
generic type, the type of this parameter will be that type. Otherwise the type is
compareAndSet() method of the
AtomicReferenceArray can compare the current reference
stored in a given element with an expected reference, and if the references are the same, swap the current reference
with a new reference. Here is a
String string1 = "string1"; String string2 = "string2"; String source = new String; source = string1; AtomicReferenceArray<String> array = new AtomicReferenceArray<String>(source); array.compareAndSet(5, string1, string2);
This example first creates a
String array and sets the element with index 5 to point to the
string1 reference. Then, it compares the value of the element with index 5 to the
reference, and if they are the same, sets the reference of the element to
string2. If no other thread
has changed the reference of the element with index 5 (which is not possible in the situation above), then the
setting succeeds (the new reference is set).
AtomicReferenceArray has several more methods that you can use for special purposes. You should
check out the JavaDoc for the
AtomicReferenceArray class to learn more about those methods.