Is i++ thread-safe (increment operation on primitive types)?

By | March 5, 2023

The increment operation i++ on primitive types is not inherently thread-safe. When multiple threads access and modify a shared variable, there is a risk of race conditions and data inconsistencies.

In particular, the i++ operation consists of two steps: reading the current value of the variable and then incrementing it by one. If multiple threads are performing i++ on the same variable simultaneously, they may read and modify the same value, leading to lost updates and inconsistent results.

To make the i++ operation thread-safe, you need to synchronize access to the shared variable. This can be done by using a lock, a synchronized block, or an atomic variable. For example, you can use a synchronized block to ensure that only one thread at a time can access and modify the variable:

synchronized (lock) {



Alternatively, you can use an atomic variable, such as an AtomicInteger, which provides thread-safe operations for incrementing and updating values:

AtomicInteger atomicInt = new AtomicInteger(0);


By using synchronization or atomic variables, you can ensure that the i++ operation is performed atomically and consistently across multiple threads.


Leave a Reply

Your email address will not be published. Required fields are marked *