Java Concurrency Tutorial
Selected Reading
- Concurrency - Discussion
- Concurrency - Useful Resources
- Concurrency - Quick Guide
- ConcurrentNavigableMap
- Concurrency - ConcurrentMap
- Concurrency - BlockingQueue
- Concurrency - Fork-Join framework
- Concurrency - Futures and Callables
- ScheduledThreadPoolExecutor
- Concurrency - ThreadPoolExecutor
- newSingleThreadExecutor
- newScheduledThreadPool
- Concurrency - newCachedThreadPool
- Concurrency - newFixedThreadPool
- ScheduledExecutorService
- Concurrency - ExecutorService
- Concurrency - Executor
- Concurrency - AtomicReferenceArray
- Concurrency - AtomicLongArray
- Concurrency - AtomicIntegerArray
- Concurrency - AtomicReference
- Concurrency - AtomicBoolean
- Concurrency - AtomicLong
- Concurrency - AtomicInteger
- Concurrency - Condition
- Concurrency - ReadWriteLock
- Concurrency - Lock
- Concurrency - ThreadLocalRandom
- Concurrency - ThreadLocal
- Concurrency - Deadlock
- Concurrency - Synchronization
- Interthread Communication
- Concurrency - Major Operations
- Concurrency - Environment Setup
- Concurrency - Overview
- Concurrency - Home
Selected Reading
- Who is Who
- Computer Glossary
- HR Interview Questions
- Effective Resume Writing
- Questions and Answers
- UPSC IAS Exams Notes
Concurrency - AtomicReferenceArray
AtomicReferenceArray Class
A java.util.concurrent.atomic.AtomicReferenceArray class provides operations on underlying reference array that can be read and written atomically, and also contains advanced atomic operations. AtomicReferenceArray supports atomic operations on underlying reference array variable. It have get and set methods that work pke reads and writes on volatile variables. That is, a set has a happens-before relationship with any subsequent get on the same variable. The atomic compareAndSet method also has these memory consistency features.
AtomicReferenceArray Methods
Following is the pst of important methods available in the AtomicReferenceArray class.
| Sr.No. | Method & Description |
|---|---|
| 1 | pubpc boolean compareAndSet(int i, E expect, E update) Atomically sets the element at position i to the given updated value if the current value == the expected value. |
| 2 | pubpc E get(int i) Gets the current value at position i. |
| 3 | pubpc E getAndSet(int i, E newValue) Atomically sets the element at position i to the given value and returns the old value. |
| 4 | pubpc void lazySet(int i, E newValue) Eventually sets the element at position i to the given value. |
| 5 | pubpc int length() Returns the length of the array. |
| 6 | pubpc void set(int i, E newValue) Sets the element at position i to the given value. |
| 7 | pubpc String toString() Returns the String representation of the current values of array. |
| 8 | pubpc boolean weakCompareAndSet(int i, E expect, E update) Atomically sets the element at position i to the given updated value if the current value == the expected value. |
Example
The following TestThread program shows usage of AtomicReferenceArray variable in thread based environment.
import java.util.concurrent.atomic.AtomicReferenceArray;
pubpc class TestThread {
private static String[] source = new String[10];
private static AtomicReferenceArray<String> atomicReferenceArray
= new AtomicReferenceArray<String>(source);
pubpc static void main(final String[] arguments) throws InterruptedException {
for (int i = 0; i<atomicReferenceArray.length(); i++) {
atomicReferenceArray.set(i, "item-2");
}
Thread t1 = new Thread(new Increment());
Thread t2 = new Thread(new Compare());
t1.start();
t2.start();
t1.join();
t2.join();
}
static class Increment implements Runnable {
pubpc void run() {
for(int i = 0; i<atomicReferenceArray.length(); i++) {
String add = atomicReferenceArray.getAndSet(i,"item-"+ (i+1));
System.out.println("Thread " + Thread.currentThread().getId()
+ ", index " +i + ", value: "+ add);
}
}
}
static class Compare implements Runnable {
pubpc void run() {
for(int i = 0; i<atomicReferenceArray.length(); i++) {
System.out.println("Thread " + Thread.currentThread().getId()
+ ", index " +i + ", value: "+ atomicReferenceArray.get(i));
boolean swapped = atomicReferenceArray.compareAndSet(i, "item-2", "updated-item-2");
System.out.println("Item swapped: " + swapped);
if(swapped) {
System.out.println("Thread " + Thread.currentThread().getId()
+ ", index " +i + ", updated-item-2");
}
}
}
}
}
This will produce the following result.
Output
Thread 9, index 0, value: item-2 Thread 10, index 0, value: item-1 Item swapped: false Thread 10, index 1, value: item-2 Item swapped: true Thread 9, index 1, value: updated-item-2 Thread 10, index 1, updated-item-2 Thread 10, index 2, value: item-3 Item swapped: false Thread 10, index 3, value: item-2 Item swapped: true Thread 10, index 3, updated-item-2 Thread 10, index 4, value: item-2 Item swapped: true Thread 10, index 4, updated-item-2 Thread 10, index 5, value: item-2 Item swapped: true Thread 10, index 5, updated-item-2 Thread 10, index 6, value: item-2 Thread 9, index 2, value: item-2 Item swapped: true Thread 9, index 3, value: updated-item-2 Thread 10, index 6, updated-item-2 Thread 10, index 7, value: item-2 Thread 9, index 4, value: updated-item-2 Item swapped: true Thread 9, index 5, value: updated-item-2 Thread 10, index 7, updated-item-2 Thread 9, index 6, value: updated-item-2 Thread 10, index 8, value: item-2 Thread 9, index 7, value: updated-item-2 Item swapped: true Thread 9, index 8, value: updated-item-2 Thread 10, index 8, updated-item-2 Thread 9, index 9, value: item-2 Thread 10, index 9, value: item-10 Item swapped: falseAdvertisements