atomic integer counter printing in wrong order

Question

I have defined the following instance variable:

private final AtomicInteger tradeCounter = new AtomicInteger(0);

I have a method called onTrade defined as below being called by 6 threads:

public void onTrade(Trade trade) {
    System.out.println(tradeCounter.incrementAndGet());
}

Why is the output:

2 5 4 3 1 6

Instead of 1 2 3 4 5 6 ?

I want to avoid using synchronization.

Try to understand the concept of AtomicInteger, it is not about ordering of numbers. — Sambit, May 23 '19 at 19:03

Michał Krzywański · Accepted Answer · 2019-05-23T19:12:51.717

You can think of

tradeCounter.incrementAndGet();

And

System.out.println();

as two separate statements. So here

System.out.println(tradeCounter.incrementAndGet());

there are basically two statements, and those statements together are not atomical.

Imagine such example with 2 threads :

Thread 1 invokes tradeCounter.incrementAndGet()
Thread 2 invokes tradeCounter.incrementAndGet()
Thread 2 prints value 2
Thread 1 prints value 1

It all depends in what order threads will invoke inctructions in your method.

score 2 · Answer 2 · answered May 23 '19 at 19:14

I have a method called onTrade defined as below being called by 6 threads:
public void onTrade(Trade trade) {
    System.out.println(tradeCounter.incrementAndGet());
}
Why is the output:

2 5 4 3 1 6

Instead of 1 2 3 4 5 6 ?

Why shouldn't that be the output? Or why not 3 1 4 6 5 2? Or any of the other permutations of 1 2 3 4 5 6?

Using an AtomicInteger and its incrementAndGet() method ensures that each each thread gets a different value, and that the six values obtained are sequential, without synchronization. But that has nothing to do with the order in which the resulting values are printed afterward.

If you want the results to be printed in the same order that they are obtained, then synchronization is the easiest way to go. In that case, using an AtomicInteger does not gain you anything over using a plain int (for this particular purpose):

int tradeCounter = 0;

synchronized public void onTrade(Trade trade) {
    System.out.println(++tradeCounter);
}

Alternatively, don't worry about the order in which the output is printed. Consider: is the output order actually meaningful for any reason?

score 1 · Answer 3 · answered May 23 '19 at 19:07

incrementAndGet() increments in the expected order : 1, 2, 3 etc... But system.out doesn't invoke the println() in an atomic way along incrementAndGet(). So the random ordering is expected.

I want to avoid using synchronization.

You could not in this case.

score 1 · Answer 4 · answered May 23 '19 at 19:08

System.out.println(...) and tradeCounter.incrementAndGet() are two separate operations and most likely when thread-i gets new value, some other threads can get value and print it before thread-i prints it. There is no way to avoid synchronization (direct or indirect) here.

atomic integer counter printing in wrong order

4 Answers4