Atomic Variables in Java

Java Atomic Classes

Java Atomic Classes are a set of classes provided by the java.util.concurrent.atomic package that encapsulate primitive data types and provide atomic operations for concurrent programming. These classes ensure thread safety without the need for explicit synchronization mechanisms such as locks or synchronized blocks.

Why use Atomic Variables in Java?

The Atomic Variables in Java come in handy in the case of concurrency. For instance, let us consider an example where we have to count the number of times a loop is running for multiple threads.

• Java

Java

class threadCount extends Thread {
    int total = 0;  // Non-atomic integer

    public void run() {
        int max = 100000;
        for (int i = 0; i < max; i++) {
            total++;  // Increment the non-atomic integer
        }
    }
}

public class Main {
    public static void main(String args[]) throws InterruptedException {
        threadCount count = new threadCount();
        Thread first = new Thread(count, "First");
        Thread second = new Thread(count, "Second");

        first.start();
        second.start();

        first.join();
        second.join();

        // Print the result that varies due to race condition
        System.out.println("Loop count without using Atomic Variables in Java: " + count.total);
    }
}

You can also try this code with Online Java Compiler

Run Code

Output: 

Loop count without using Atomic Variables in Java: 133060
 

As is clearly visible from the above output, the program gives a different outcome for each execution. But is it supposed to happen? No, the program should return 200000 as the output for each execution. So why does it happen? The fault occurs because of concurrency. At times the threads may execute simultaneously, causing a write problem. We can overcome this using two methods,

• Using Synchronization
• Using Atomic Variables in Java

Read More About, Basics of Java, Why is Java Platform Independent

Using Synchronisation

We can solve the issue of concurrency using the synchronization function in Java.

• Java

Java

import java.io.*;
import java.util.*;
class threadCount extends Thread {
	int total = 0;
	public synchronized void run(){
		int max = 100000;
			for (int i = 0; i < max; i++) {
				total++;
		}
	}
}

public class usingSync {
	public static void main(String args[])throws InterruptedException{
		threadCount count = new threadCount();
		Thread first = new Thread(count, "First");
		Thread second = new Thread(count, "Second");
		first.start();
		second.start();
		first.join();
		second.join();
		System.out. println("Loop count using Synchronisation: "+count.total);
	}
}

You can also try this code with Online Java Compiler

Run Code

Output

Loop count using Synchronisation: 200000

As you can see, no matter how many times the program is executed, it returns the same and correct output. We can also achieve this using the Atomic Variables in Java.

Try it on java online compiler.

Using Atomic Variables in Java

There are various methods present in Atomic Variables in Java, for example.

• get(): This method is used to fetch the current value of the Atomic Variable in Java.
• addAndGet(int val): This method is used to atomically add the given value to the current value of the Atomic Variable in Java.
• decrementAndGet(): This method is used to decrease the value of the variable.

Users can create an instance of the Atomic Variable class and call these functions directly.

Let us look at how to implement the above problem using Atomic Variables in Java,

• Java

Java

import java.util.concurrent.atomic.AtomicInteger;
class threadCount extends Thread {
	//creating an instance of Atomic Variable Class
	AtomicInteger total;
	threadCount(){
		total = new AtomicInteger();
	}
	public void run(){
		int max = 100000;
		for (int i = 0; i < max; i++) {
			//Calling the addAndGet function
			total.addAndGet(1);
		}
	}
}

public class usingAtomic {
	public static void main(String args[])throws InterruptedException{
		threadCount count = new threadCount();
		Thread first = new Thread(count, "First");
		Thread second = new Thread(count, "Second");
		first.start();
		second.start();
		first.join();
		second.join();
		System.out. println("Loop count using Atomic Variables in Java: "+count.total);
	}
}

You can also try this code with Online Java Compiler

Run Code

Output

Loop count using Atomic Variables in Java: 200000

You can also read about the Multiple Inheritance in Java.

Frequently Asked Questions

What is the atomic concept of Java?

The atomic concept in Java refers to operations that are indivisible and appear as if they occur instantaneously, ensuring thread safety without explicit synchronization.

What is atomic in multithreading?

In multithreading, atomic refers to operations that are performed atomically, without interference from other threads, ensuring thread safety.

Are the Atomic Variables in Java thread-safe?

Yes, Atomic Variables in Java are thread-safe. They ensure thread safety by providing atomic operations without the need for explicit synchronization mechanisms.

Why do we use atomic variables in Java?

We use atomic variables in Java to ensure thread-safe, lock-free operations on shared variables in multithreaded environments. They provide efficient and non-blocking synchronization using Compare-and-Set (CAS) operations, simplifying code and avoiding performance overhead of traditional locking mechanisms.

What package is associated with Atomic Variables in Java?

The Atomic Variable class can be imported into your Java code using the java.util.concurrent.atomic package.

Conclusion

Atomic variables in Java are a powerful tool for achieving thread-safe and efficient operations in multithreaded applications. By leveraging the Compare-and-Set (CAS) mechanism, they eliminate the need for traditional locking, reducing complexity and enhancing performance. Whether you're managing counters, flags, or shared references, atomic classes provide a clean and effective way to handle concurrency challenges.

Recommended Articles

• Multiple Inheritance in Java.
• Multithreading in java