类成员的最小值和最大值

Question

我试图了解两个线程是更新的class会员的可能值是什么，当我运行程序时输出总是20，但我想了解为什么它会发生以及什么是mimumum，class会员的最大值

public class TestClass {


public int classMember = 0;
    private void updateCM() {
        for (int i = 0; i < 10; i++) {
            classMember++;
        }
    }
public static void main(String[] args) {

    TestClass mainClass = new TestClass();
    Thread t1 = new Thread(mainClass::updateCM);
    Thread t2 = new Thread(mainClass::updateCM);

    t1.start();
    t2.start();

    while(t1.isAlive() || t2.isAlive()) {}

    System.out.println(mainClass.classMember);
}

}

Answer 1

所有介于10和20（包括10和20）之间的值都是可能的结果。

在最坏的情况下，一个线程的每个增量（不是原子增量，由读内存、增量、写内存组成）都与其他线程交错。

可能的交错（为方便起见，省略了“增加”操作）：

Thread1  Thread2
Read 0
         Read 0
Write 1
         Write 1
Read 1
         Read 1
Write 2
         Write 2
Read 2
         Read 2
Write 3
         Write 3
Read 3
         Read 3
Write 4
         Write 4
Read 4
         Read 4
Write 5
Read 5
         Write 5
         Read 5
Write 6
Read 6
         Write 6
         Read 6
Write 7
Read 7
         Write 7
         Read 7
Write 8
Read 8
         Write 8
         Read 8
Write 9
Read 9
         Write 9
         Read 9
         Write 10
Write 10

另一种可能的交错：

Thread1  Thread2
Read 0
         Read 0
         Write 1
         Read 1
         Write 2
         Read 2
         Write 3
         Read 3
         Write 4
         Read 4
         Write 5
         Read 5
         Write 6
         Read 6
         Write 7
         Read 7
         Write 8
         Read 8
         Write 9
         Read 9
         Write 10
Write 1
Read 1
Write 2
Read 2
Write 3
Read 3
Write 4
Read 4
Write 5
Read 5
Write 6
Read 6
Write 7
Read 7
Write 8
Read 8
Write 9
Read 9
Write 10

Answer 2

增量不是原子操作，所以每次运行程序时结果可能会不同。在这种情况下，我认为，第一个线程只是在处理器给第二个线程执行操作的时间之前完成了变量值的递增。但是，如果你，例如，启动两个线程，其中第一个会将变量的值递减十亿次，而第二个线程则相反——将其递增十亿次，你会得到一些非常意想不到的东西（当然，如果你不打算让这个变量线程安全的话）。

Answer 3

我想你需要阅读这个Stackoverflow线程

使多个线程使用并更改同一变量

由于要在同一实例中更新同一变量，因此可能会出现同步问题。对于这种情况，合适的关键字应该是volatile。但是，即使将volatile设置为变量，这也不够，因为实际上不是一个操作，而是三个操作，这使得它不是原子操作。

我也会引用这段话

虽然这会处理内存同步，但它不一定会保护您免受竞争条件的影响。认识到这实际上是3个操作也很重要：获取当前值，增加值，然后再次存储。如果多个线程正在尝试执行此操作，则存在可能导致错过操作的线程争用情况。在这种情况下，您应该使用AtomicInteger类，它包装了一个volatile int字段。它提供了incrementAndGet（）等方法，这些方法以线程安全的方式递增该字段。