原子/易失性/同步之间有什么区别？

您是在专门询问它们在内部是如何工作的，所以您在这里：

没有同步

private int counter;

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

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

private boolean stopped;

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

public void pleaseStop() {
    stopped = true;
}

将 volatile 添加到 stopped 变量并且它工作正常 - 如果任何其他线程通过 pleaseStop() 方法修改 stopped 变量，您可以保证在工作线程的 while(!stopped) 循环中立即看到该更改。顺便说一句，这也不是中断线程的好方法，请参阅：How to stop a thread that is running forever without any use 和 Stopping a specific java thread。

原子整数

private AtomicInteger counter = new AtomicInteger();

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

AtomicInteger 类使用 CAS (compare-and-swap) 低级 CPU 操作（不需要同步！）它们允许您仅在当前值等于其他值（并成功返回）时修改特定变量。因此，当您执行 getAndIncrement() 时，它实际上是在循环中运行（简化的实际实现）：

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

所以基本上：阅读；尝试存储增量值；如果不成功（值不再等于 current），请读取并重试。 compareAndSet() 在本机代码（程序集）中实现。

无同步的易失性

private volatile int counter;

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

此代码不正确。它修复了可见性问题（volatile 确保其他线程可以看到对 counter 所做的更改），但仍然存在竞争条件。这已 explained 多次：前/后增量不是原子的。

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

无同步的易失性 (2)

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

与上述相同的问题，但更糟糕的是因为 i 不是 private。竞争条件仍然存在。为什么会出现问题？例如，如果两个线程同时运行此代码，则输出可能是 + 5 或 + 10。但是，您可以保证看到更改。

多个独立同步

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

令人惊讶的是，此代码也不正确。事实上，这是完全错误的。首先，您要在即将更改的 i 上进行同步（此外，i 是一个原语，所以我猜您是在通过自动装箱创建的临时 Integer 上同步...）完全有缺陷。你也可以写：

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

没有两个线程可以使用相同的锁进入同一个 synchronized 块。在这种情况下（在您的代码中也是如此），锁定对象在每次执行时都会更改，因此 synchronized 实际上没有任何效果。

即使您使用了最终变量（或 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;
  }
}

---

将变量声明为 volatile 意味着修改其值会立即影响变量的实际内存存储。编译器无法优化对变量所做的任何引用。这保证了当一个线程修改变量时，所有其他线程立即看到新值。 （对于非易失性变量，这不能保证。）

声明原子变量保证了对变量进行的操作以原子方式发生，即，操作的所有子步骤都在它们执行的线程内完成，并且不会被其他线程中断。例如，增量和测试操作要求变量递增，然后与另一个值进行比较；原子操作保证这两个步骤都将完成，就好像它们是一个不可分割/不可中断的操作一样。

同步对变量的所有访问一次只允许一个线程访问该变量，并强制所有其他线程等待该访问线程释放其对变量的访问。

同步访问类似于原子访问，但原子操作通常在较低的编程级别实现。此外，完全有可能只同步对变量的某些访问而允许其他访问不同步（例如，同步对变量的所有写入但不同步对变量的读取）。

原子性、同步性和易变性是独立的属性，但通常结合使用以强制执行适当的线程协作以访问变量。

附录（2016 年 4 月）

对变量的同步访问通常使用监视器或信号量来实现。这些是低级互斥（互斥）机制，允许线程独占地获取对变量或代码块的控制，如果所有其他线程也尝试获取相同的互斥，则强制所有其他线程等待。一旦拥有线程释放互斥锁，另一个线程可以依次获取互斥锁。

附录（2016 年 7 月）

同步发生在对象上。这意味着调用类的同步方法将锁定调用的 this 对象。静态同步方法将锁定 Class 对象本身。

同样，进入同步块需要锁定方法的 this 对象。

这意味着如果同步方法（或块）锁定在不同的对象上，则它们可以同时在多个线程中执行，但对于任何给定的单个对象，一次只能有一个线程执行同步方法（或块）。

---

易挥发的：

volatile 是关键字。 volatile 强制所有线程从主内存而不是缓存中获取变量的最新值。访问 volatile 变量不需要锁定。所有线程都可以同时访问 volatile 变量值。

使用 volatile 变量可降低内存一致性错误的风险，因为对 volatile 变量的任何写入都会与随后读取该相同变量建立起先发生关系。

这意味着对 volatile 变量的更改始终对其他线程可见。此外，这还意味着当线程读取 volatile 变量时，它不仅会看到 volatile 的最新更改，还会看到导致更改的代码的副作用。

何时使用：一个线程修改数据，其他线程必须读取数据的最新值。其他线程会采取一些行动，但不会更新数据。

原子XXX：

AtomicXXX 类支持对单个变量进行无锁线程安全编程。这些 AtomicXXX 类（如 AtomicInteger）解决了内存不一致错误/修改易失性变量的副作用，这些变量已在多个线程中访问。

何时使用：多个线程可以读取和修改数据。

同步：

synchronized 是用于保护方法或代码块的关键字。通过将方法设为同步有两个效果：

首先，同一对象上的同步方法的两次调用不可能交错。当一个线程正在为一个对象执行同步方法时，所有其他为同一对象调用同步方法的线程都会阻塞（暂停执行），直到第一个线程处理完该对象。其次，当同步方法退出时，它会自动与任何后续对同一对象的同步方法调用建立起之前的关系。这保证了对象状态的更改对所有线程都是可见的。

何时使用：多个线程可以读取和修改数据。您的业务逻辑不仅会更新数据，还会执行原子操作

AtomicXXX 等效于 volatile + synchronized，即使实现不同。 AmtomicXXX 扩展了 volatile 个变量 + compareAndSet 个方法，但不使用同步。

相关的 SE 问题：

Difference between volatile and synchronized in Java

Volatile boolean vs AtomicBoolean

值得阅读的好文章：（以上内容取自这些文档页面）

https://docs.oracle.com/javase/tutorial/essential/concurrency/sync.html

https://docs.oracle.com/javase/tutorial/essential/concurrency/atomic.html

https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html

---

我知道两个线程不能同时进入同步块

两个线程不能两次进入同一个对象上的同步块。这意味着两个线程可以进入不同对象的同一个块。这种混乱可能导致这样的代码。

private Integer i = 0;

synchronized(i) {
   i++;
}

这不会像预期的那样表现，因为它可能每次都锁定在不同的对象上。

如果这是真的，那么这个 atomic.incrementAndGet() 如何在没有 Synchronize 的情况下工作？线程安全吗？

是的。它不使用锁定来实现线程安全。

如果您想更详细地了解它们的工作原理，可以阅读它们的代码。

内部读取和写入易失性变量/原子变量有什么区别？

原子类使用 volatile 字段。领域没有区别。不同之处在于执行的操作。 Atomic 类使用 CompareAndSwap 或 CAS 操作。

我在一些文章中读到线程具有变量的本地副本那是什么？

我只能假设它指的是每个 CPU 都有自己的内存缓存视图，这可能与其他所有 CPU 不同。为确保您的 CPU 具有一致的数据视图，您需要使用线程安全技术。

只有当内存共享至少一个线程更新它时，这才是一个问题。

---

同步 Vs 原子 Vs 易失性：

易失性和原子性仅适用于变量，而同步适用于方法。

Volatile 确保了对象的可见性而不是原子性/一致性，而其他都确保了可见性和原子性。

易失性变量存储在 RAM 中，访问速度更快，但没有同步关键字，我们无法实现线程安全或同步。

同步实现为同步块或同步方法，而两者都不是。我们可以在 synchronized 关键字的帮助下线程安全的多行代码，而两者都无法实现。

同步可以锁定相同的类对象或不同的类对象，而两者都不能。

如果我遗漏了什么，请纠正我。

---

volatile + 同步是一个万无一失的解决方案，可以让操作（语句）完全原子化，其中包括对 CPU 的多条指令。

例如：volatile int i = 2; i++，就是 i = i + 1；这使得执行该语句后 i 在内存中的值为 3。这包括从内存中读取 i 的现有值（即 2），加载到 CPU 累加器寄存器中并通过将现有值增加一个（累加器中的 2 + 1 = 3）来进行计算，然后写回增加的值回到记忆中。尽管 i 的值是易变的，但这些操作还不够原子。 i 是 volatile 只保证从内存中的 SINGLE 读/写是原子的，而不是 MULTIPLE。因此，我们还需要在 i++ 周围进行同步，以使其成为万无一失的原子语句。请记住一个语句包含多个语句的事实。

希望解释足够清楚。

---

Java volatile 修饰符是保证线程之间发生通信的特殊机制的一个示例。当一个线程写入 volatile 变量，而另一个线程看到该写入时，第一个线程将告诉第二个内存的所有内容，直到它执行对该 volatile 变量的写入。

原子操作在单个任务单元中执行，不受其他操作的干扰。原子操作在多线程环境中是必要的，以避免数据不一致。

---