What is the use of atomic in Java?

Ans: The atomic classes are used to provide a lock-free and thread-safe environment or programming on a single variable. It also supports atomic operations.

When can we use volatile variables in Java?

Ans: We can use a volatile variable if we want to read and write long and double variables automatically.

Can we make the array volatile in Java?

Ans: Yes, We can make an array (both primitive and reference type array, e.g., an int array and String array) volatile in Java.

Why do we need synchronization?

Ans: The need for synchronization originates when processes need to execute concurrently. The main purpose of synchronization is to share resources without interference using mutual exclusion.

Table of contents

Introduction

1.1.

Atomic

1.2.

Volatile

1.3.

Synchronized

Atomic

2.1.

Example

Volatile

3.1.

Example

Synchronized

4.1.

Example

Difference between Atomic, Volatile, and Synchronized

Frequently Asked Questions

Key takeaways

Last Updated: Mar 27, 2024

Easy

Difference between Atomic, Volatile, and Synchronized

Author Shivam Verma

Do you think IIT Guwahati certified course can help you in your career?

Yes

Introduction

Before knowing about the difference between Atomic, Volatile, and Synchronized, we have to know about these things.

Atomic

Atomic is a toolkit of variable java.util.concurrent.atomic package classes assist in writing lock and wait-free algorithms with the Java language.

Volatile

Volatile is a keyword used to modify the value of a variable by different threads. It is also used to make class thread-safe.

Synchronized

Synchronized is a keyword used to define a block of code where multiple threads can safely access the same variable.

You can also read about the Multiple Inheritance in Java.

Atomic

Atomic variable guarantees that the operations made on the variable occur in an atomic manner.
Atomic variables are classes, and these classes come from the package java.util.concurrent.atomic.
Example: AtomicInteger, AtomicBoolean, AtomicLong, etc.

Example

import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.concurrent.atomic.AtomicInteger;
class Atomic_example implements Runnable
{
    private AtomicInteger count=new AtomicInteger();
    public void run()
    {
        for(int i=1;i<=5; i++)
        {
            try
            {
                Thread.sleep(i*50);
                count.getAndIncrement();
            }
            catch (InterruptedException ex)
            { 
                System.out.println(ex);
            }
        }
    }
    public int get_count()
    { 
        return count.get();
    }
}
public class Example
{
    public static void main(String[] args) throws InterruptedException
    {
        Atomic_example r=new Atomic_example();
        Thread th1 = new Thread(r);
        th1.start();
        Thread th2 = new Thread(r);
        th2.start();
        th1.join();
        th2.join();
        System.out.println("Count Value " + r.get_count());
    }
}

You can also try this code with Online Java Compiler

Run Code

Output

Count Value 10

Volatile

Volatile is a keyword that is used to modify the value of a variable by different threads.
We can use the volatile keyword with variables. Using a volatile keyword with classes and methods is illegal.
When we have our variables as volatile, they are always visible to other threads.
If you declared the variable as volatile, Read and Writes are atomic.
We can use it as an alternative way of achieving synchronization in Java.

Example

import java.lang.*;
import java.io.*;
class volatile_example implements Runnable
{
    private static volatile boolean stopRequested;
    public void run()
    {
        int i=0;
        while(!stopRequested)
        {
            i++;
        }
        System.out.println("backgroundThread completed");
    }
    public void update()
    { 
        stopRequested=true;
    }


}
public class Example
{
    public static void main(String[] args) throws InterruptedException
    {
        volatile_example vo=new volatile_example();
        Thread bth= new Thread(vo);
        bth.start();
        Thread.sleep(1000);
        vo.update();
        System.out.println("Main completed");
    }
}

You can also try this code with Online Java Compiler

Run Code

Output

Main completed
backgroundThread completed

Try it by yourself on java online compiler.

Synchronized

It allows only a single thread at a time to access the shared resource. It will not allow other threads and make the other threads wait for that accessing thread to release its access to the shared resource.
Each object in Java has a unique lock. So when a thread wants to execute a shared resource, it has to obtain the lock on that object, thereby avoiding other threads to access the same object.
It can be applied to methods and blocks. It actually occurs on the object. For any given single object, only one thread can execute a synchronized method/block at a time.

Example

import java.util.*;
import java.lang.*;
import java.io.*;
class RaceCondition implements Runnable
{
    private int count;
    public void run()
    {
        for(int i=1;i<=5; i++)
        {
            try
            {
                Thread.sleep(i*50);
                count++;
            }
            catch (InterruptedException ex)
            { 
                System.out.println(ex);
            }
        }
    }
    public int get_count()
    { 
        return count;
    }
}
public class Example
{
    public static void main(String[] args) throws InterruptedException
    {
        RaceCondition r=new RaceCondition();
        Thread th1 = new Thread(r);
        th1.start();
        Thread th2 = new Thread(r);
        th2.start();
        th1.join();
        th2.join();
        System.out.println("Count Value " + r.get_count());
    }
}

You can also try this code with Online Java Compiler

Run Code

Output

Count Value 10

Must Read Static Blocks In Java, Multithreading in Python