1. Java Concurrency Utilities - java.util.concurrent
2. Java BlockingQueue
3. ArrayBlockingQueue
4. DelayQueue
5. LinkedBlockingQueue
6. PriorityBlockingQueue
7. SynchronousQueue
8. BlockingDeque
9. LinkedBlockingDeque
10. ConcurrentMap
11. ConcurrentNavigableMap
12. CountDownLatch
13. CyclicBarrier
14. Exchanger
15. Semaphore
16. Java ExecutorService
17. Java Callable
18. Java Future
19. ThreadPoolExecutor
20. ScheduledExecutorService
21. Java ForkJoinPool
22. Java Lock
23. ReadWriteLock
24. AtomicBoolean
25. AtomicInteger
26. AtomicLong
27. AtomicReference
28. AtomicStampedReference
29. AtomicIntegerArray
30. AtomicLongArray
31. AtomicReferenceArray

• Creating an AtomicLongArray
• get()
• set()
• compareAndSet()
• addAndGet()
• getAndAdd()
• incrementAndGet()
• getAndIncrement()
• decrementAndGet()
• getAndDecrement()
• Additional Methods

The Java AtomicLongArray class (java.util.concurrent.atomic.AtomicLongArray) represents an array of long . The long elements in the AtomicLongArray can be updated atomically. The AtomicLongArray also supports compare-and-swap functionality.

Creating an AtomicLongArray

You can create an AtomicLongArray using one of its two constructors.

The first constructor takes an int as parameter. This int specifies the length of the AtomicLongArray to create, meaning how many elements it should have space for. Here is a Java example of creating an AtomicLongArray using this constructor:

AtomicLongArray array = new AtomicLongArray(10);

This example creates a AtomicLongArray with a capacity of 10 longs (it has space for 10 long elements).

The second constructor takes a long[] array as parameter. The AtomicLongArray 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 AtomicLongArray. Here is a Java example of creating an AtomicLongArray using this constructor:

long[] longs = new long[10];

longs[5] = 123;

AtomicLongArray array = new AtomicLongArray(longs);

This example first creates a long[] array and sets a value into the element with index 5. Then it creates an AtomicLongArray with the long[] array as parameter.

get()

You can get the value of a given element using the get() method on the AtomicLongArray. Here is an example showing how calling the get() method looks:

long value = array.get(5);

set()

You can set the value of a given element using the set() method on the AtomicLongArray. Here is an example showing how calling the set() method looks:

array.set(5, 999);

compareAndSet()

The compareAndSet() method is used to compare the value of a given element with a specified value, and if the two values are equal, set a new value for that element. This is an example of the atomic compare-and-swap functionality support by the AtomicLongArray. Only one thread at a time can execute the compareAndSet() method.

Here is how calling the compareAndSet() method of the AtomicLongArray:

boolean swapped = array.compareAndSet(5, 999, 123);

This example compares the element with index 5 to the expected value 999, and if equal, sets the new value 123 for the element with index 5. The compareAndSet() method returns a boolean with the value true if the element had a new value set, and false if not (if the element did not have the expected value).

addAndGet()

The AtomicLongArray also contains a method that can be used to add a value to a given element, and return the new value of the element. Calling addAndGet() is also an atomic operation (like all operations on the AtomicLongArray). Here is an example of calling addAndGet() :

long newValue = array.addAndGet(5, 3);

After executing this code the newValue variable would contain the value of the element with index 5 with 3 added to it.

getAndAdd()

The AtomicLongArray class also contains a method named getAndAdd(). The getAndAdd() method does the same as the addAndGet() method, except the getAndAdd() method returns the value of the element before a value is added to it. Here is a getAndAdd() example:

long oldValue = array.getAndAdd(5, 3);

After executing this code the oldValue variable would contain the old value of the element with index 5, before the value 3 was added to it.

incrementAndGet()

The incrementAndGet() method increments (adds 1) to the value of a given element and returns the new value of that element. Here is a incrementAndGet() example:

long newValue = array.incrementAndGet(5);

After executing this code the newValue variable would contain the value of the element with index 5 with 1 added to it.

getAndIncrement()

The AtomicLongArray class also contains a method named getAndIncrement(). The getAndIncrement() method does the same as the incrementAndGet() method, except the getAndIncrement() method returns the value of the element before it is incremented. Here is a getAndIncrement() example:

long oldValue = array.getAndIncrement(5);

After executing this code the oldValue variable would contain the old value of the element with index 5, before it was incremented (1 was added to it).

decrementAndGet()

The decrementAndGet() method decrements (subtracts 1) to the value of a given element and returns the new value of that element. Here is a decrementAndGet() example:

long newValue = array.decrementAndGet(5);

After executing this code the newValue variable would contain the value of the element with index 5 with 1 subtracted from it.

getAndDecrement()

The AtomicLongArray class also contains a method named getAndDecrement(). The getAndDecrement() method does the same as the decrementAndGet() method, except the getAndDecrement() method returns the value of the element before it is decremented. Here is a getAndDecrement() example:

long oldValue = array.getAndDecrement(5);

After executing this code the oldValue variable would contain the old value of the element with index 5, before it was decremented (1 was subtracted from it).

Additional Methods

The AtomicLongArray has several more methods that you can use for special purposes. You should check out the JavaDoc for the AtomicLongArray class to learn more about those methods.