Why is i++ not atomic?

Question

Why is i++ not atomic in Java?

To get a bit deeper in Java I tried to count how often the loop in threads are executed.

So I used a

private static int total = 0;

in the main class.

I have two threads.

• Thread 1: Prints System.out.println("Hello from Thread 1!");
• Thread 2: Prints System.out.println("Hello from Thread 2!");

And I count the lines printed by thread 1 and thread 2. But the lines of thread 1 + lines of thread 2 don't match the total number of lines printed out.

Here is my code:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Test {

    private static int total = 0;
    private static int countT1 = 0;
    private static int countT2 = 0;
    private boolean run = true;

    public Test() {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        newCachedThreadPool.execute(t1);
        newCachedThreadPool.execute(t2);
        try {
            Thread.sleep(1000);
        }
        catch (InterruptedException ex) {
            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
        }
        run = false;
        try {
            Thread.sleep(1000);
        }
        catch (InterruptedException ex) {
            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println((countT1 + countT2 + " == " + total));
    }

    private Runnable t1 = new Runnable() {
        @Override
        public void run() {
            while (run) {
                total++;
                countT1++;
                System.out.println("Hello #" + countT1 + " from Thread 1! Total hello: " + total);
            }
        }
    };

    private Runnable t2 = new Runnable() {
        @Override
        public void run() {
            while (run) {
                total++;
                countT2++;
                System.out.println("Hello #" + countT2 + " from Thread 2! Total hello: " + total);
            }
        }
    };

    public static void main(String[] args) {
        new Test();
    }
}

Fanjet

Why don't you try with AtomicInteger? – Delmerdelmor

See also: another SO question, ++ not considered atomic, Concurrency in Java. – Octan

@user2864740, why do you say AtomicInteger is not atomic? You can use the getAndIncrement method to do this. It is atomic. – Phyliciaphylis

the JVM has an iinc operation for incrementing integers, but that only works for local variables, where concurrency is not a concern. For fields, the compiler generates read-modify-write commands separately. – Alfons

Why would you even expect it to be atomic? – Np

Even on hardware that implements an "increment storage location" instruction, there's no guarantee that that's thread-safe. Just because an operation can be represented as a single operator says nothing about it's thread-safety. – Np

@Silly Freak: even if there was an iinc instruction for fields, having a single instruction does not guarantee atomicity, e.g. non-volatile long and double field access in not guaranteed to be atomic regardless of the fact that it is performed by a single bytecode instruction. – Basildon

This question highlights the usefulness of learning assembly language. – Katusha

Answer 1

i++ is probably not atomic in Java because atomicity is a special requirement which is not present in the majority of the uses of i++. That requirement has a significant overhead: there is a large cost in making an increment operation atomic; it involves synchronization at both the software and hardware levels that need not be present in an ordinary increment.

You could make the argument that i++ should have been designed and documented as specifically performing an atomic increment, so that a non-atomic increment is performed using i = i + 1. However, this would break the "cultural compatibility" between Java, and C and C++. As well, it would take away a convenient notation which programmers familiar with C-like languages take for granted, giving it a special meaning that applies only in limited circumstances.

Basic C or C++ code like for (i = 0; i < LIMIT; i++) would translate into Java as for (i = 0; i < LIMIT; i = i + 1); because it would be inappropriate to use the atomic i++. What's worse, programmers coming from C or other C-like languages to Java would use i++ anyway, resulting in unnecessary use of atomic instructions.

Even at the machine instruction set level, an increment type operation is usually not atomic for performance reasons. In x86, a special instruction "lock prefix" must be used to make the inc instruction atomic: for the same reasons as above. If inc were always atomic, it would never be used when a non-atomic inc is required; programmers and compilers would generate code that loads, adds 1 and stores, because it would be way faster.

In some instruction set architectures, there is no atomic inc or perhaps no inc at all; to do an atomic inc on MIPS, you have to write a software loop which uses the ll and sc: load-linked, and store-conditional. Load-linked reads the word, and store-conditional stores the new value if the word has not changed, or else it fails (which is detected and causes a re-try).

Treadwell

as java has no pointers, incrementing local variables is inherently thread save, so with loops the problem mostly wouldn't be so bad. your point about least surprise stands, of course. also, as it is, i = i + 1 would be a translation for ++i, not i++ – Alfons

The first word of the question is "why". As of now, this is the only answer to address the issue of "why". The other answers really just re-state the question. So +1. – Edeline

It might be worth noting that an atomicity guaranty would not solve the visibility issue for updates of non-volatile fields. So unless you will treat every field as implicitly volatile once one thread has used the ++ operator on it, such an atomicity guaranty would not solve concurrent update issues. So why potentially wasting performance for something if it doesn’t solve the problem. – Basildon

@DavidWallace don't you mean ++? ;) – Porty

"Even at the machine instruction set level, an increment type operation is usually not atomic for performance reasons." Is it because it involves "multiple steps" at machine instruction level? – Senskell

@Senskell It requires complex support to be atomic across multiple processor cores, whereas an ordinary increment instruction just has to perform a load, add and store. – Treadwell

Answer 2

i++ involves two operations :

1. read the current value of i
2. increment the value and assign it to i

When two threads perform i++ on the same variable at the same time, they may both get the same current value of i, and then increment and set it to i+1, so you'll get a single incrementation instead of two.

Example :

int i = 5;
Thread 1 : i++;
           // reads value 5
Thread 2 : i++;
           // reads value 5
Thread 1 : // increments i to 6
Thread 2 : // increments i to 6
           // i == 6 instead of 7

Dramamine

(Even if i++ was atomic, it would not be well-defined/thread-safe behavior.) – Swithbert

+1, but "1. A, 2. B and C" sounds like three operations, not two. :) – Ender

Note that even if the operation were implemented with a single machine instruction that incremented a storage location in place, there is no guarantee it would be thread-safe. The machine still needs to fetch the value, increment it, and store it back, plus there may be multiple cache copies of that storage location. – Np

@HotLicks Not necessarily. If the fetch, increment and store are done atomically, or in one single "transaction" (on the CPU level), then it's presumably thread-safe. Although, yes, there may be cached copies, but that's a different story. I think the only possible contention would be if the incrementing thread were paused (due to kernel scheduling) before the increment operation completed, possibly allowing another thread to read the variable. I would think it depends upon the threading implementation, OS, and CPU. – Telson

@Telson - If two processors execute the same operation against the same storage location simultaneously, and there is no "reserve" broadcast on the location, then they will almost certainly interfere and produce bogus results. Yes, it is possible for this operation to be "safe", but it takes special effort, even at the hardware level. – Np

But I think the question was "Why" and not "What happens". – Buhrstone

@phresnel I interpreted the question differently, since if the op wanted to know why java creators chose not to make ++ atomic, there was no need for all the code posted. The code implied they asked why the code behaves the way it does. Based on the accepted answer I may have been wrong. – Dramamine

Thank you; however, I think, that 1) read current; 2)increment; 3) assign it back is still three operations :) – Gdynia

Answer 3

Java specification

The important thing is the JLS (Java Language Specification) rather than how various implementations of the JVM may or may not have implemented a certain feature of the language.

The JLS defines the ++ postfix operator in clause 15.14.2 which says i.a. "the value 1 is added to the value of the variable and the sum is stored back into the variable". Nowhere does it mention or hint at multithreading or atomicity.

For multithreading or atomicity, the JLS provides volatile and synchronized. Additionally, there are the Atomic… classes.

Floatable

Answer 4

Why is i++ not atomic in Java?

Let's break the increment operation into multiple statements:

Thread 1 & 2 :

1. Fetch value of total from memory
2. Add 1 to the value
3. Write back to the memory

If there is no synchronization then let's say Thread one has read the value 3 and incremented it to 4, but has not written it back. At this point, the context switch happens. Thread two reads the value 3, increments it and the context switch happens. Though both threads have incremented the total value, it will still be 4 - race condition.

Litotes

I don't get how this should be an answer to the question. A language can define any feature as atomic, be it increments or unicorns. You just exemplify a consequence of not being atomic. – Buhrstone

Yes a language can define any feature as atomic but as far as java is considered increment operator(which is the question posted by OP) is not atomic and my answer states the reasons. – Litotes

(sorry for my harsh tone in first comment) But then, the reason seems to be "because if it would be atomic, then there would be no race conditions". I.e., it sounds as if a race condition is desirable. – Buhrstone

@phresnel the overhead introduced to keep an increment atomic is huge and rarely desired, keeping the operation cheap and as a result non atomic is desirable most of the time. – Syracuse

@josefx: Note that I am not questioning the facts, but the reasoning in this answer. It basically says "i++ is not atomic in Java because of the race conditions it has", which is like saying "a car has no airbag because of the crashes that can happen" or "you get no knife with your currywurst-order because the wurst may need to be cut". Thus, I don't think this is an answer. The question was not "What does i++ do?" or "What is the consequence of i++ not being synced?". – Buhrstone

Answer 5

i++ is a statement which simply involves 3 operations:

1. Read current value
2. Write new value
3. Store new value

These three operations are not meant to be executed in a single step or in other words i++ is not a compound operation. As a result all sorts of things can go wrong when more than one threads are involved in a single but non-compound operation.

Consider the following scenario:

Time 1:

Thread A fetches i
Thread B fetches i

Time 2:

Thread A overwrites i with a new value say -foo-
Thread B overwrites i with a new value say -bar-
Thread B stores -bar- in i

// At this time thread B seems to be more 'active'. Not only does it overwrite 
// its local copy of i but also makes it in time to store -bar- back to 
// 'main' memory (i)

Time 3:

Thread A attempts to store -foo- in memory effectively overwriting the -bar- 
value (in i) which was just stored by thread B in Time 2.

Thread B has nothing to do here. Its work was done by Time 2. However it was 
all for nothing as -bar- was eventually overwritten by another thread.

And there you have it. A race condition.

---

That's why i++ is not atomic. If it was, none of this would have happened and each fetch-update-store would happen atomically. That's exactly what AtomicInteger is for and in your case it would probably fit right in.

P.S.

An excellent book covering all of those issues and then some is this: Java Concurrency in Practice

Haricot

Hmm. A language can define any feature as atomic, be it increments or unicorns. You just exemplify a consequence of not being atomic. – Buhrstone

@phresnel Exactly. But I also point out that it's not a single operation which by extension implies that the computational cost for turning multiple such operations into atomic ones is much more expensive which in turn -partially- justifies why i++ is not atomic. – Haricot

While I get your point, your answer is a bit confusing to the learning. I see an example, and a conclusion that says "because of the situation in the example"; imho this is an incomplete reasoning :( – Buhrstone

@phresnel Maybe not the most pedagogical answer but it's the best I can currently offer. Hopefully it will help people and not confuse them. Thanks for critisism however. I 'll try to be more precise in my future posts. – Haricot

Answer 6

In the JVM, an increment involves a read and a write, so it's not atomic.

Highboy

Answer 7

If the operation i++ would be atomic you wouldn't have the chance to read the value from it. This is exactly what you want to do using i++ (instead of using ++i).

For example look at the following code:

public static void main(final String[] args) {
    int i = 0;
    System.out.println(i++);
}

In this case we expect the output to be: 0 (because we post increment, e.g. first read, then update)

This is one of the reasons the operation can't be atomic, because you need to read the value (and do something with it) and then update the value.

The other important reason is that doing something atomically usually takes more time because of locking. It would be silly to have all the operations on primitives take a little bit longer for the rare cases when people want to have atomic operations. That is why they've added AtomicInteger and other atomic classes to the language.

Splore

This is misleading. You have to separate execution and getting the result, otherwise you couldn't get values from any atomic operation. – Buhrstone

No it isn't, that is why Java's AtomicInteger has a get(), getAndIncrement(), getAndDecrement(), incrementAndGet(), decrementAndGet() etc. – Splore

And the Java-language could have defined i++ to be expanded to i.getAndIncrement(). Such expanding isn't new. E.g., lambdas in C++ are expanded to anonymous class definitions in C++. – Buhrstone

Given an atomic i++ one can trivially create an atomic ++i or vice-versa. One is equivalent to the other plus one. – Loudmouth

Answer 8

There are two steps:

1. fetch i from memory
2. set i+1 to i

so it's not atomic operation. When thread1 executes i++, and thread2 executes i++, the final value of i may be i+1.

Duteous

Answer 9

In Java, the i++ operation is not atomic because it is actually a combination of multiple steps that can be interrupted by other threads. The i++ operation consists of three distinct steps: reading the current value of i, incrementing the value by 1, and storing the updated value back into i. Each of these steps is a separate operation and can be interleaved with operations from other threads, leading to potential race conditions.

A race condition occurs when multiple threads access a shared resource concurrently, and the result of the operation depends on the specific order of execution. In the case of i++, if two or more threads attempt to increment i at the same time, they may read the same initial value of i, increment it separately, and then store their individual results back into i. This can lead to lost updates, where one or more increments are overwritten, resulting in an incorrect final value of i.

To ensure atomicity and avoid race conditions, Java provides the AtomicInteger class, which encapsulates an integer value and provides atomic operations on that value. Instead of using int i, you can use AtomicInteger i and perform atomic increments using the incrementAndGet() method. This method guarantees that the increment operation is performed atomically and eliminates the possibility of race conditions.

Here's an example that demonstrates the atomic increment using AtomicInteger:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Test {

    private static AtomicInteger total = new AtomicInteger(0);
    private static AtomicInteger countT1 = new AtomicInteger(0);
    private static AtomicInteger countT2 = new AtomicInteger(0);
    private boolean run = true;

    public Test() {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        newCachedThreadPool.execute(t1);
        newCachedThreadPool.execute(t2);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ex) {
            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
        }
        run = false;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ex) {
            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println((countT1.get() + countT2.get() + " == " + total.get()));
    }

    private Runnable t1 = new Runnable() {
        @Override
        public void run() {
            while (run) {
                total.incrementAndGet();
                countT1.incrementAndGet();
                System.out.println("Hello #" + countT1.get() + " from Thread 1! Total hello: " + total.get());
            }
        }
    };

    private Runnable t2 = new Runnable() {
        @Override
        public void run() {
            while (run) {
                total.incrementAndGet();
                countT2.incrementAndGet();
                System.out.println("Hello #" + countT2.get() + " from Thread 2! Total hello: " + total.get());
            }
        }
    };

    public static void main(String[] args) {
        new Test();
    }
}

Fanjet

Answer 10

In JVM or any VM, the i++ is equivalent to the following:

int temp = i;     // 1. read
i = temp + 1;    // 2. increment the value then 3. write it back

that is why i++ is non-atomic.

Overt

That is how it is non-atomic, not why, as so many of the other answers and comments have covered. – Ploch

Answer 11

Concurrency (the Thread class and such) is an added feature in v1.0 of Java. i++ was added in the beta before that, and as such is it still more than likely in its (more or less) original implementation.

It is up to the programmer to synchronize variables. Check out Oracle's tutorial on this.

Edit: To clarify, i++ is a well defined procedure that predates Java, and as such the designers of Java decided to keep the original functionality of that procedure.

The ++ operator was defined in B (1969) which predates java and threading by just a tad.

Chalybeate

-1 "public class Thread ... Since: JDK1.0" Source: docs.oracle.com/javase/7/docs/api/index.html?java/lang/… – Alfons

The version doesn't matter so much as the fact that it was still implemented before the Thread class and was not changed because of it, but I've edited my answer to please you. – Chalybeate

What matters is that your claim "it was still implemented before the Thread class" is not backed by sources. i++ not being atomic is a design decision, not an oversight in a growing system. – Alfons

Lol that's cute. i++ was defined well before Threads, simply because there were languages that existed before Java. The creators of Java used those other languages as a base instead of redefining a well accepted procedure. Where did I ever say it was an oversight? – Chalybeate

@SillyFreak Here's some sources that show how old ++ is: en.wikipedia.org/wiki/Increment_and_decrement_operators en.wikipedia.org/wiki/B_(programming_language) – Chalybeate

Just because a language feature is borrowed from or inspired by a corresponding feature in other languages doesn't mean it necessarily keeps the exact same underlying characteristics. Consider, for instance, the variety of lambda functions in different languages (e.g. the weakness of Python's lambda compared to true Lisp lambdas symbo1ics.com/blog/?p=1292). Even in C++, certain features taken from C aren't quite identical to their C counterparts, despite the fact that C++ is often thought to be backwards-compatible with C (cprogramming.com/tutorial/c-vs-c++.html). – Blemish

@TheBat: But many borrowed keywords and operators are not implemented like in the language/s they were borrowed from. E.g., class and operator. in C++ are totally orthogonal to their Java "equivalents". – Buhrstone