Today we will look into AtomicInteger in Java. Atomic operations are performed in a single unit of task without interference from other operations. Atomic operations are necessity in multi-threaded environment to avoid data inconsistency.
AtomicInteger
Let’s create a simple multi-threaded program where every thread increments the shared count variable 4 times. So if there are two threads, after they finish count value should be 8.
JavaAtomic.java
Copy
package com.journaldev.concurrency;
public class JavaAtomic {
public static void main(String[] args) throws InterruptedException {
ProcessingThread pt = new ProcessingThread();
Thread t1 = new Thread(pt, "t1");
t1.start();
Thread t2 = new Thread(pt, "t2");
t2.start();
t1.join();
t2.join();
System.out.println("Processing count=" + pt.getCount());
}
}
class ProcessingThread implements Runnable {
private int count;
@Override
public void run() {
for (int i = 1; i < 5; i++) {
processSomething(i);
count++;
}
}
public int getCount() {
return this.count;
}
private void processSomething(int i) {
// processing some job
try {
Thread.sleep(i * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
If you will run above program, you will notice that count value varies between 5,6,7,8. The reason is because count++ is not an atomic operation. So by the time one threads read it’s value and increment it by one, other thread has read the older value leading to wrong result.
To solve this issue, we will have to make sure that increment operation on count is atomic, we can do that using Synchronization but Java 5 java.util.concurrent.atomic provides wrapper classes for int and long that can be used to achieve this atomic operation without usage of Synchronization.
Java AtomicInteger Example
Here is the updated program that will always output count value as 8 because AtomicInteger method incrementAndGet() atomically increments the current value by one.
Copy
package com.journaldev.concurrency;
import java.util.concurrent.atomic.AtomicInteger;
public class JavaAtomic {
public static void main(String[] args) throws InterruptedException {
ProcessingThread pt = new ProcessingThread();
Thread t1 = new Thread(pt, "t1");
t1.start();
Thread t2 = new Thread(pt, "t2");
t2.start();
t1.join();
t2.join();
System.out.println("Processing count=" + pt.getCount());
}
}
class ProcessingThread implements Runnable {
private AtomicInteger count = new AtomicInteger();
@Override
public void run() {
for (int i = 1; i < 5; i++) {
processSomething(i);
count.incrementAndGet();
}
}
public int getCount() {
return this.count.get();
}
private void processSomething(int i) {
// processing some job
try {
Thread.sleep(i * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
Benefits of using Concurrency classes for atomic operation is that we don’t need to worry about synchronization. This improves code readability and chance of errors are reduced. Also atomic operation concurrency classes are assumed to be more efficient that synchronization which involves locking resources.
Vimal Panchal says
March 31, 2019 at 9:45 pmCan we use instead of AtomicInteger, CountDownLatch for the multithread environment?
Prakash says
June 14, 2018 at 6:59 amThanks for the nice and valuable article Pankaj !!!
Can you share any idea on how to ensure consistency and thread safe for a String shared by multiple threads.
Or do I need to use any other dataType for TEXT type ???
Thanks in advance
Pankaj says
June 14, 2018 at 10:43 amString is immutable, so it’s thread-safe. You can use it in the multithreaded environment.
Radhika Sharma says
March 29, 2018 at 3:51 amGreat Job Pankaj . Blogs are very simple and helpful .
ashu says
July 3, 2017 at 8:48 pmHello Sir
I understand the concept but there is one thing I am failing to understand. If i remove the processSomething(i) call, then every time i am getting the count=8. I tried for almost 20 times but every time got perfect 8.
Can you please explain why
ashu says
July 3, 2017 at 8:58 pmI think i got the reason, If i increase the loop from 4 to say 5000 then i am get the expected result(somthing between 5000 and 10000). I think 4 is to small a count , whenever a thread will get some cpu time it will be able to increase the counter by 4.
Prashant says
October 12, 2016 at 11:27 pmI think we need better explanation, not just the syntax on how to use AtomicInteger, its available everywhere else on the internet.
Nitin says
January 7, 2016 at 11:58 pmThis is a wrong explanation u r joining both threads . Did not expect this dumb kind of explanation from such a senior analyst.
Clear ur concepts first.
Pankaj says
January 8, 2016 at 12:15 amThanks for calling me a senior analyst. And what is the problem with join()? It’s used so that main method finishes after both the threads and we can simulate the problem.
Praneet Pushpal says
February 2, 2016 at 9:07 amI think t1.join() will block other threads until t1 is terminated and then t2.join() will block other threads until t2 completes. In this case threads will run sequentially t1 then t2 then main thread.
So, join should not be there in this explanation. Correct me if I am wrong.
Shuo Zhang says
December 25, 2017 at 8:47 amNo you didn’t understand join() method. When you add some log in the ProcessingThread like
System.out.printf(“%s: %d\n”,Thread.currentThread().getName(),this.getCount()) you will understand better;
Yogesh Bombe says
July 3, 2018 at 4:24 amYou are right.
jeesk says
October 3, 2018 at 8:01 amI think that Thread.sleep(i * 1);, So thread main, t1 and t2 are running parallel. .
if don’t use Thread.sleep(); So t1 and t2 are running order;
Prianc says
February 22, 2016 at 8:05 amClear you concepts first. And before that clear your concepts of how to talk in comments section. knowledge is give and take relationship. Why so angry if you know something.
craig says
April 9, 2018 at 10:59 amwell said
Ram says
May 12, 2016 at 4:19 amHe has called the join after issuing the start command on both the threads. The subsequent joins will pause the main thread until t1 and t2 are complete. Why do you think they would be sequential
Swapnil says
June 29, 2018 at 7:35 amI don’t see any issue with the example. Thread main, t1 and t2 are running parallel. Check when start() method is called. t1.join() makes main thread to wait for t1’s completion and then t2.join() makes main thread to wait for t2’s completion. It’s not like t1 and t2 are not running parallel. Definitely t1 and t2 are running parallel.
Very nice Pankaj for this article.
IM says
December 1, 2015 at 10:37 pmI think the count value going “5,6,7,8” is perfectly acceptable in your first example isn’t it?
But Yes. I got the concept.
ASHISH JAIN(Technical Consultant) says
August 7, 2018 at 5:03 amI think the count value will be always 8.
Wells Lee says
April 29, 2015 at 12:59 amit’s very usefully for me ,this is my first time visited this site.The tutorials understandability,thanks a lot.But i didn’t understand how to use Atomic integer class?
Lalita says
November 13, 2014 at 5:22 amGood site for java interview preparation. But i didn’t understand why to use Atomic integer class. Can you please provide the scenario where we can use this
sachin says
October 29, 2014 at 3:13 amHi,
Simply i can modify the program you suggested above for atomic but i haven’t seen any benefit of this atomic variable because in both cases i am getting same result. So can you please provide another example for the same to see what exactly it is..
package test;
import java.util.concurrent.atomic.AtomicInteger;
public class JavaAtomic {
public static void main(String[] args) throws InterruptedException {
ProcessingThread pt = new ProcessingThread();
Thread t1 = new Thread(pt, “t1”);
Thread t2 = new Thread(pt, “t2”);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(“Processing count=” + pt.getCount());
}
}
class ProcessingThread implements Runnable {
// private AtomicInteger count = new AtomicInteger();
int count = 0;
@Override
public void run() {
// count.incrementAndGet();
for (int i = 0; i < 4; i++) {
count++;
}
}
public int getCount() {
// return this.count.get();
return count;
}
}
Umesh says
January 27, 2017 at 2:58 pmYeah its late reply, but will help others.
try to put a sleep(100) in run method, and run your program 8~10 times again & again, you will get it.
Also @Pankaj, Thanks a lot for such great tutorials, Journaldev is best among others. Great work
Sorrowfull Blinger says
August 27, 2014 at 10:53 pmHow is atomicity incorporated into the Atomic Integer class? it has to be via locks right ?? Then how is this different from Synchronisation block?
Pankaj says
August 27, 2014 at 11:57 pmYes internally it must be using locks but because Java provides guarantee of atomic operations, we don’t need to implement it ourself, this is the plus point.
Prashant says
October 12, 2016 at 11:25 pmI dont think its using locks since synchronization reduces the throughput of the execution and AtomicIntegers are used in lock-free implementation.
Pallavi says
March 21, 2018 at 9:43 amInternally Atomic integer is volatile integer. Through Volatility, it is providing Atmicity.
Every read and write operation happens from memory,
Deepak D says
December 16, 2018 at 7:05 pmNot true IMO. Atomic Integers are more Thread Safer than volatile variables. volatile guarantees only the exact value at any point, but does not guarantee thread safety. meaning to say since ++ operation internally involves 2 operations 1 for reading other for doing +1. Using volatile in multi-threaded scenario will result in race condition.
Explanation : when Thread 1 calls ++ first it reads the volatile variable value (assume value is 2) since ++ is two operation , before even the first Thread increment the value second Thread reads the volatile variable value (at this point value is still 2) now first 1 incremented value from 2 to 3, and second Thread also does the same as the value was 2 when second the Thread read it. Finally the result would be 3, but expected is 4.
Dharmendra Sahu says
January 20, 2014 at 6:35 amThanks a lot this tutorial.
suresh says
December 23, 2013 at 10:21 amnice blog sir…thanks a lot…
Alex says
October 22, 2013 at 10:43 pmThank you very much for your site and tutorials!
You are doing very great job, even after almost 7 years in java development i can find something new in your blog posts!
Thank you very much and good luck!