Difference between i++ and i = i+1 in terms of atomicity

Question

I know that i++ is not a thread safe operation. I also understand why i++ is faster than i = i+1 also. Is i = i+1 any different from i++ in terms of thread safety? Any bytecode level explanation would be really helpful.

Answer 1

Neither i += 1 nor i++ is atomic (neither is thread safe). The same goes for ++i. Here's a simple test you can run to prove this:

public class Test {

    static volatile int x, y;

     static class IncThread extends Thread {
         public void run() {
            for (int i=0; i<50000; i++) x++;
            for (int i=0; i<50000; i++) y = y+1;
         }
     }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new IncThread();
        Thread t2 = new IncThread();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.printf("x = %d, y = %d%n", x, y);
    }

}

Here's what I get for output:

x = 99897, y = 81556

Obviously, some of the writes got lost. There's a nice little blog post, ++ not considered atomic, that explains this. That post also points out that @August's answer is misleading. That bytecode (iinc) is only generated for incrementing local variables, which are not interesting from the perspective of thread-safety. (The blog post also talks about the different bytecodes used for increments.)

Answer 2

There is no difference between i++ and i += 1, bytecode-wise:

Increment (Source):

public static void main(String[] args) {
    int i = 0;
    i++;
}

Increment (Bytecode):

public static void main(java.lang.String[]);
    Code:
       0: iconst_0      
       1: istore_1      
       2: iinc          1, 1
       5: return

---

Compound addition (Source):

public static void main(String[] args) {
    int i = 0;
    i += 1;
}

Compound addition (Bytecode):

public static void main(java.lang.String[]);
    Code:
       0: iconst_0      
       1: istore_1      
       2: iinc          1, 1
       5: return 

The bytecode used for incrementing fields is also the same, although it doesn't use the iinc instruction (because it would need a local variable index):

int x;

void inc() { x++; }
void assign() { x += 1; }

---

void inc();
    Code:
       0: aload_0       
       1: dup           
       2: getfield      #2                  // Field x:I
       5: iconst_1      
       6: iadd          
       7: putfield      #2                  // Field x:I
      10: return        

  void assign();
    Code:
       0: aload_0       
       1: dup           
       2: getfield      #2                  // Field x:I
       5: iconst_1      
       6: iadd          
       7: putfield      #2                  // Field x:I
      10: return    

Answer 3

i=i+1 uses a binary operator (+) which loads the value of i, and adds one to it, and then store the result back to i. In contrast, i++ uses the unary (++) operator which simply increments the value using a single assembly instruction, so in theory it could be more efficient. However, with today's compilers optimization i=i+1 and i++ will result in the same optimized code.

Answer 4

There is no differences between i++ and i=i+1 in those terms.