Java i++ 分析

java 里 i++ 不是线程安全的。

测试如下：

public class Main {
    static int m = 0;
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    m++;
                }
            }).start();
        }
        Thread.sleep(300);
        System.out.println(m);
    }
}

//结果：
//2127（每次不一样，小于等于3000）

再看一个例子：

public class Main {
    int i = 0;
    void f() {
        i++;
    }
}

查看一下它的字节码（javap -c Main）

F:\Test\src>javac Main.java
F:\Test\src>javap -c Main
Compiled from "Main.java"
public class Main {
  int i;

  public Main();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: iconst_0
       6: putfield      #2                  // Field i:I
       9: return

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

其中 f() 方法的字节码是这部分：

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

解释一下各个命令的含义：

aload_0：将第一个引用类型本地变量送至栈顶（这里即 this 的引用）
dup：复制栈顶值并将复制值压入栈顶
getfield：取指定类的实例域，并将其压入栈顶
iconst_1：将 int 型 1 压入栈顶
iadd：将栈顶两 int 型数值相加并将结果压入栈顶
putfield：为指定类的实例域赋值

接着通过图来看看栈的出入情况：

可以看出，i++ 的步骤其实分为三步，取数，相加，放回，即：

t1 = i;
t2 = t1 + 1;
i = t2;

在取数和放回之间别的线程可能也会执行，这样便有可能发生丢失更新问题，如下图：

这样一来，线程2 的更新就会被线程1的操作覆盖，从而丢失，所以，i++ 是线程不安全的。

要解决这个问题，可以使用 synchronized 关键字：

public class Main {
    int i = 0;
    void f() {
        synchronized (this) {
            i++;
        }
    }
}