你特别问了他们内部是如何运作的，所以你是这样的:
没有同步
private int counter;
public int getNextUniqueIndex() {
return counter++;
}
It basically reads value from memory, increments it and puts back to memory. This works in single thread but nowadays, in the era of multi-core, multi-CPU, multi-level caches it won't work correctly. First of all it introduces race condition (several threads can read the value at the same time), but also visibility problems. The value might only be stored in "local" CPU memory (some cache) and not be visible for other CPUs/cores (and thus - threads). This is why many refer to local copy of a variable in a thread. It is very unsafe. Consider this popular but broken thread-stopping code:
private boolean stopped;
public void run() {
while(!stopped) {
//do some work
}
}
public void pleaseStop() {
stopped = true;
}
将volatile添加到stopped变量中，它工作得很好——如果任何其他线程通过pleaseStop()方法修改了stopped变量，你可以保证在工作线程的while(!stopped)循环中立即看到该更改。顺便说一句，这也不是一个中断线程的好方法，参见:如何停止一个永远运行而没有任何用途的线程和停止一个特定的java线程。
AtomicInteger
private AtomicInteger counter = new AtomicInteger();
public int getNextUniqueIndex() {
return counter.getAndIncrement();
}
AtomicInteger类使用CAS(比较和交换)底层CPU操作(不需要同步!)它们允许您仅在当前值等于其他值(并且成功返回)时修改特定变量。所以当你执行getAndIncrement()时，它实际上在循环中运行(简化的实际实现):
int current;
do {
current = get();
} while(!compareAndSet(current, current + 1));
基本上就是:阅读;尝试储存增加的价值;如果不成功(该值不再等于current)，请读取后重试。compareAndSet()是在本机代码(程序集)中实现的。
不同步的Volatile
private volatile int counter;
public int getNextUniqueIndex() {
return counter++;
}
这段代码不正确。它修复了可见性问题(volatile确保其他线程可以看到counter所做的更改)，但仍然存在竞态条件。这已经解释了很多次:前/后增量不是原子的。
volatile的唯一副作用是“刷新”缓存，以便所有其他方都能看到最新版本的数据。这在大多数情况下都太严格了;这就是为什么volatile不是默认值。
不同步易变(2)
volatile int i = 0;
void incIBy5() {
i += 5;
}
同样的问题，但更糟糕的是，因为i不是私有的。竞态条件仍然存在。为什么这是个问题?如果两个线程同时运行这段代码，那么输出可能是+ 5或+ 10。但是，您一定会看到变化。
多独立同步
void incIBy5() {
int temp;
synchronized(i) { temp = i }
synchronized(i) { i = temp + 5 }
}
令人惊讶的是，这段代码也是不正确的。事实上，这是完全错误的。首先，你正在同步i，这是即将被改变的(此外，i是一个原语，所以我猜你正在同步一个通过自动装箱创建的临时整数…)完全有缺陷的。你也可以这样写:
synchronized(new Object()) {
//thread-safe, SRSLy?
}
没有两个线程可以使用相同的锁进入相同的同步块。在这种情况下(在您的代码中也类似)，锁对象在每次执行时都会改变，因此同步实际上没有任何影响。
即使您使用了最终变量(或this)进行同步，代码仍然是不正确的。两个线程可以首先同步地将i读入temp(在temp中有相同的本地值)，然后第一个线程将一个新值赋给i(比如，从1到6)，另一个线程做同样的事情(从1到6)。
同步必须从读取到赋值。第一次同步没有效果(读取int是原子的)，第二次也是如此。在我看来，这些是正确的形式:
void synchronized incIBy5() {
i += 5
}
void incIBy5() {
synchronized(this) {
i += 5
}
}
void incIBy5() {
synchronized(this) {
int temp = i;
i = temp + 5;
}
}