关于Java：atomic / volatile / synchronized的区别是什么？

What is the difference between atomic / volatile / synchronized?

原子/易失性/同步如何在内部工作？

以下代码块之间的区别是什么？

代码1

1
2
3
4
5

private int counter;

public int getNextUniqueIndex() {
return counter++;
}

代码2

1
2
3
4
5

private AtomicInteger counter;

public int getNextUniqueIndex() {
return counter.getAndIncrement();
}

代码3

1
2
3
4
5

private volatile int counter;

public int getNextUniqueIndex() {
return counter++;
}

volatile是否按以下方式工作？是

1
2
3
4

volatile int i = 0;
void incIBy5() {
i += 5;
}

相当于

1
2
3
4
5
6

Integer i = 5;
void incIBy5() {
int temp;
synchronized(i) { temp = i }
synchronized(i) { i = temp + 5 }
}

我认为两个线程不能同时进入同步块…我说的对吗？如果这是真的，那么没有synchronized，atomic.incrementAndGet()是如何工作的？它是安全的吗？

内部读取和写入易失变量/原子变量有什么区别？我在一些文章中读到线程有变量的本地副本——那是什么？

相关讨论

您特别询问了它们的内部工作方式，下面是：

不同步

1
2
3
4
5

private int counter;

public int getNextUniqueIndex() {
return counter++;
}

它基本上是从内存中读取值，将其递增并返回到内存中。这在单线程中工作，但在多核、多CPU、多级别缓存的时代，它无法正常工作。首先，它引入了竞争条件(多个线程可以同时读取值)，但也引入了可见性问题。该值可能只存储在"本地"CPU内存(某些缓存)中，而对于其他CPU/核心(因此是线程)则不可见。这就是为什么许多引用线程中变量的本地副本的原因。它非常不安全。考虑一下这个流行但中断的线程停止代码：

1
2
3
4
5
6
7
8
9
10
11

private boolean stopped;

public void run() {
while(!stopped) {
//do some work
}
}

public void pleaseStop() {
stopped = true;
}

将volatile添加到stopped变量中，它工作得很好——如果有任何其他线程通过pleaseStop()方法修改stopped变量，您一定能在工作线程的while(!stopped)循环中立即看到这种变化。顺便说一下，这不是中断线程的好方法，请参见：如何停止永远运行的线程，而不需要任何使用和停止特定的Java线程。

AtomicInteger

1
2
3
4
5

private AtomicInteger counter = new AtomicInteger();

public int getNextUniqueIndex() {
return counter.getAndIncrement();
}

AtomicInteger类使用cas(比较和交换)低级CPU操作(不需要同步！)它们只允许您在当前值等于其他值(并且成功返回)时修改特定变量。因此，当您执行getAndIncrement()时，它实际上是在一个循环中运行的(简化的实际实现)：

1
2
3
4

int current;
do {
current = get();
} while(!compareAndSet(current, current + 1));

因此，基本上是：读取；尝试存储递增值；如果不成功(该值不再等于current，则读取并重试。compareAndSet()是以本机代码(assembly)实现的。

volatile不同步

1
2
3
4
5

private volatile int counter;

public int getNextUniqueIndex() {
return counter++;
}

此代码不正确。它修复了可见性问题(volatile确保其他线程可以看到对counter所做的更改)，但仍具有争用条件。这已经解释了多次：递增前/递增后不是原子的。

volatile的唯一副作用是"刷新"缓存，以便所有其他方都能看到最新版本的数据。这在大多数情况下都太严格了；这就是为什么volatile不是默认值。

不同步的volatile(2)

1
2
3
4

volatile int i = 0;
void incIBy5() {
i += 5;
}

与上述问题相同，但更糟的是，因为i不是private。比赛条件仍然存在。为什么会有问题？如果两个线程同时运行这个代码，那么输出可能是+ 5或+ 10。但是，您一定会看到变化。

多独立synchronized。

1
2
3
4
5

void incIBy5() {
int temp;
synchronized(i) { temp = i }
synchronized(i) { i = temp + 5 }
}

令人惊讶的是，这个代码也不正确。事实上，这是完全错误的。首先，你正在同步i，这将要被改变(而且，i是一个原始的，所以我猜你正在同步一个临时Integer，通过自动氧化……创建)完全有缺陷。你也可以写：

1
2
3

synchronized(new Object()) {
//thread-safe, SRSLy?
}

两个线程不能用同一个锁进入同一个synchronized块。在这种情况下(和代码中的情况类似)，锁对象在每次执行时都会发生更改，因此synchronized实际上没有任何效果。

即使使用了最后一个变量(或this)进行同步，代码仍然不正确。两个线程首先可以同步读取i到temp(在temp中具有相同的本地值)，然后第一个线程为i分配一个新值(即从1到6)，另一个线程执行相同的操作(从1到6)。

同步必须从读取到赋值。第一次同步没有效果(读取int是原子的)，第二次同步也没有效果。在我看来，这些是正确的形式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

void synchronized incIBy5() {
i += 5
}

void incIBy5() {
synchronized(this) {
i += 5
}
}

void incIBy5() {
synchronized(this) {
int temp = i;
i = temp + 5;
}
}