Why Isn\'t `i ` Atomic in Java?

Why is i Not Atomic in Java?

In Java, the i operator is not atomic, meaning that if two threads attempt to increment the same variable concurrently, the result may be incorrect. This is because the i operation consists of three separate steps:

1. Reading the current value of the variable
2. Incrementing the value
3. Writing the new value back to the variable

If two threads execute these steps simultaneously, it is possible that one thread will read the value before the other thread has incremented it. This can lead to data corruption.

For example, consider the following code:

class Test {
  private static int total = 0;

  public static void main(String[] args) {
    Thread thread1 = new Thread(new Runnable() {
      @Override
      public void run() {
        for (int i = 0; i < 100000; i++) {
          total++;
        }
      }
    });

    Thread thread2 = new Thread(new Runnable() {
      @Override
      public void run() {
        for (int i = 0; i < 100000; i++) {
          total++;
        }
      }
    });

    thread1.start();
    thread2.start();

    thread1.join();
    thread2.join();

    System.out.println("Total: " + total);
  }
}

When this code is run, it is expected to print 200000, but it may actually print a lower value due to the non-atomic nature of the i operator.

To ensure that multi-threaded code accesses shared variables atomically, it is necessary to use synchronization mechanisms such as locks or atomic variables. The synchronized keyword can be used to synchronize access to blocks of code, while the AtomicInteger class provides an atomic integer type.

The above is the detailed content of Why Isn\'t `i ` Atomic in Java?. For more information, please follow other related articles on the PHP Chinese website!