Friday, April 10, 2015


Atomic operations are singular ( an operation which cannot be stopped in between). Just like a transaction it happens completely or does not happen at all. The operations which are atomic :
  1. Read and write for reference variables
  2. Read and write for byte, short, int, char, float and Boolean
  3. Read and write for all variables declared with volatile qualifier ( this include all primitive types)
Operations like increment and decrement looks like atomic operations, but there is guarantee for the same. As any increment operation x++ can be a group of three operations
a)      Temporary copy of x will be created
b)      Temporary copy will be incremented
c)       Newly incremented value will be written back to variable x

Variables of type double and long are 64 bit and can be accessed by 2 32-bit operations. During concurrent programming, this can create compromise integrity of data. Java.util.concurrent provides atomic APIs to solve this problem. Let us take a look at an example:

package atomicops;

import java.util.concurrent.atomic.AtomicLong;

 * @author Nancy
public class TestAtomicLong {
    public static void main(String[] args) {
        AtomicLong myLong= new AtomicLong(25);
        long x = myLong.getAndAdd(20);
        System.out.println("x ="+x);
        System.out.println("x ="+x);
        x = myLong.addAndGet(30);
        System.out.println("x ="+x);
        boolean b = myLong.compareAndSet(75,100);
        System.out.println("b ="+b);
        System.out.println("x ="+x);
        x= myLong.incrementAndGet();
         x= myLong.decrementAndGet();

Output :
x =25
x =45
x =75
b =true
x =100

Other Atomic operation classes are : 

11th April, 2015
2:34 am

No comments:

Post a Comment