猫头鹰的深夜翻译：核心JAVA并发一

简介

从创建以来，JAVA就支持核心的并发概念如线程和锁。这篇文章会帮助从事多线程编程的JAVA开发人员理解核心的并发概念以及如何使用它们。

（博主将在其中加上自己的理解以及自己想出的例子作为补充）

概念

原子性：原子操作是指该系列操作要么全部执行，要么全部不执行，因此不存在部分执行的状态。
可见性：一个线程能够看见另一个线程所带来的改变。

竞争情况

当多个线程在一个共享的资源上执行一组操作时，会产生竞争。根据各个线程执行操作的顺序可能产生多个不同结果。下面的代码不是线程安全的，value可能会被初始化多次，因为check-then-act型（先判断是否为null，然后初始化）的惰性初始化并非原子性操作。

1 2 3 4 5 6 7 8

class <T> { private volatile T value; T get() { if (value == null) value = initialize(); return value; } }

数据冲突

当两个或多个线程在没有同步的情况下试图访问同一个非final变量时，会产生数据冲突。不使用同步可能使数据的改变对别的线程不可见，从而可能读取过期的数据，并导致如无限循环，数据结构损坏和不准确的计算等后果。下面这段代码可能会导致无限循环，因为读者线程可能永远都没有看到写入者线程做出的更改：

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

class Waiter implements Runnable { private boolean shouldFinish; void finish() { shouldFinish = true; } public void run() { long iteration = 0; while (!shouldFinish) { iteration++; } System.out.println("Finished after: " + iteration); } } class DataRace { public static void main(String[] args) throws InterruptedException { Waiter waiter = new Waiter(); Thread waiterThread = new Thread(waiter); waiterThread.start(); waiter.finish(); waiterThread.join(); } }

JAVA内存模型：happens-before关系

JAVA内存模型是根据读写字段等操作来定义的，并在控制器上进行同步。操作根据happens-before关联排序，这解释了一个线程何时能够看到另一个线程操作的结果，以及是什么构成了一个同步良好的程序。

happens-before关联有以下属性：

• Thread#start的方法在线程的所有操作之前执行
• 在释放当前控制器之后，后序的请求才可以获取控制器。(Releasing a monitor happens before any subsequent acquisition of the same monitor.)
• 写入volatile变量的操作在所有后序读取该变量的操作之前执行。
• 写入final型变量的操作在发布该对象的引用之前执行
• 线程的所有操作在从Thread#join方法返回之前执行

上图中，Action X在Action Y之前执行，因此线程1在Action X以前执行的所有操作对线程2在Action Y之后的所有操作可见。

标注的同步功能

synchronized关键字

synchronized关键字用来防止不同的线程同时进入一段代码。它确保了你的操作的原子性，因为你只有获得了这段代码的锁才能进入这段代码，使得该锁所保护的数据可以在独占模式下操作。除此以外，它还确保了别的线程在获得了同样的锁之后，能够观察到之前线程的操作。

1 2 3 4 5 6 7 8 9 10

class AtomicOperation { private int counter0; private int counter1; void increment() { synchronized (this) { counter0++; counter1++; } } }

synchronized关键字也可以在方法层上声明。

静态方法：将持有该方法的类作为加锁对象
非静态方法：加锁this指针

锁是可重入的。所以如果一个线程已经持有了该锁，它可以一直访问该锁下的任何内容：

1 2 3 4 5 6 7 8 9 10 11 12

class Reentrantcy { synchronized void doAll() { doFirst(); doSecond(); } synchronized void doFirst() { System.out.println("First operation is successful."); } synchronized void doSecond() { System.out.println("Second operation is successful."); } }

争用程度影响如何获得控制器：

初始化：刚刚创建，没有被获取
biased：锁下的代码只被一个线程执行，不会产生冲突
thin：控制器被几个线程无冲突的获取。使用CAS（compare and swap）来管理这个锁
fat：产生冲突。JVM请求操作系统互斥，并让操作系统调度程序处理线程停放和唤醒。

wait/notify

wait/notify/notifyAll方法在Object类中声明。wait方法用来将线程状态改变为WAITING或是TIMED_WAITING(如果传入了超时时间值)。要想唤醒一个线程，下列的操作都可以实现：

• 另一个线程调用notify方法，唤醒在控制器上等待的任意的一个线程
• 另一个线程调用notifyAll方法，唤醒在该控制器上等待的所有线程
• Thread#interrupt方法被调用，在这种情况下，会抛出InterruptedException

最常用的一个模式是一个条件性循环：

1 2 3 4 5 6 7 8 9 10 11 12

class ConditionLoop { private boolean condition; synchronized void waitForCondition() throws InterruptedException { while (!condition) { wait(); } } synchronized void satisfyCondition() { condition = true; notifyAll(); } }

• 记住，要想使用对象上的wait/notify/notifyAll方法，你首先需要获取对象的锁
• 总是在一个条件性循环中等待，从而解决如果另一个线程在wait开始之前满足条件并且调用了notifyAll而导致的顺序问题。而且它还防止线程由于伪唤起继续执行。
• 时刻确保你在调用notify/notifyAll之前已经满足了等待条件。如果不这样的话，将只会发出一个唤醒通知，但是在该等待条件上的线程永远无法跳出其等待循环。

---

博主备注：这里解释一下为何建议将wait放在条件性循环中、假设现在有一个线程，并没有将wait放入条件性循环中，代码如下：大专栏  猫头鹰的深夜翻译：核心JAVA并发一r/>

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

class UnconditionLoop{ private boolean condition; synchronized void waitForCondition() throws InterruptedException{ wait(); } synchronized void satisfyCondition(){ condition = true; notifyAll(); } }

假设现在有两个线程分别同时调用waitForCondition和satisfyCondition()，而调用satisfyCondition的方法先调用完成，并且发出了notifyAll通知。鉴于waitForCondition方法根本没有进入wait方法，因此它就错过了这个解挂信号，从而永远无法被唤醒。

这时你可能会想，那就使用if判断一下条件呗，如果条件还没满足，就进入挂起状态，一旦接收到信号，就可以直接执行后序程序。代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

class UnconditionLoop{ private boolean condition; private boolean condition2; synchronized void waitForCondition() throws InterruptedException{ if(!condition){ wait(); } } synchronized void waitForCondition2() throws InterruptedException{ if(!condition2){ wait(); } } synchronized void satisfyCondition(){ condition = true; notifyAll(); } synchronized void satisfyCondition2(){ condition2 = true; notifyAll(); } }

那让我们再假设这个 方法中还存在另一个condition，并且也有其对应的等待和唤醒方法。假设这时satisfyConsition2被满足并发出nofityAll唤醒所有等待的线程，那么waitForCondition和waitForCondition2都将会被唤醒继续执行。而waitForCondition的条件并没有被满足！

因此在条件中循环等待信号是有必要的。

---

volatile关键字

volatile关键字解决了可见性问题，并且使值的更改原子化，因为这里存在一个happens-before关联：对volatile值的更改会在所有后续读取该值的操作之前执行。因此，它确保了后序所有的读取操作能够看到之前的更改。

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

class VolatileFlag implements Runnable { private volatile boolean shouldStop; public void run() { while (!shouldStop) { //do smth } System.out.println("Stopped."); } void stop() { shouldStop = true; } public static void main(String[] args) throws InterruptedException { VolatileFlag flag = new VolatileFlag(); Thread thread = new Thread(flag); thread.start(); flag.stop(); thread.join(); } }

Atomics

java.util.concurrent.atomic包中包含了一组支持在单一值上进行多种原子性操作的类，从而从加锁中解脱出来。

使用AtomicXXX类，可以实现原子性的check-then-act操作：

1 2 3 4 5 6 7 8

class CheckThenAct { private final AtomicReference<String> value = new AtomicReference<>(); void initialize() { if (value.compareAndSet(null, "Initialized value")) { System.out.println("Initialized only once."); } } }

AtomicInteger和AtomicLong都用increment/decrement操作：

1 2 3 4 5 6 7

class Increment { private final AtomicInteger state = new AtomicInteger(); void advance() { int oldState = state.getAndIncrement(); System.out.println("Advanced: '" + oldState + "' -> '" + (oldState + 1) + "'."); } }

如果你想要创建一个计数器，但是并不需要原子性的读操作，可以使用LongAdder替代AtomicLong/AtomicInteger，LongAdder在多个单元格中维护该值，并在需要时对这些值同时递增，从而在高并发的情况下性能更好。

ThreadLocal

在线程中包含数据并且不需要锁定的一种方法是使用ThreadLocal存储。从概念上将，ThreadLocal就好像是在每个线程中都有自己版本的变量。ThreadLocal常用来存储只属于线程自己的值，比如当前的事务以及其它资源。而且，它还能用来维护单个线程专有的计数器，统计或是ID生成器。

1 2 3 4 5 6 7 8 9 10 11 12

class TransactionManager { private final ThreadLocal<Transaction> currentTransaction = ThreadLocal.withInitial(NullTransaction::new); Transaction currentTransaction() { Transaction current = currentTransaction.get(); if (current.isNull()) { current = new TransactionImpl(); currentTransaction.set(current); } return current; } }

原文链接: https://dzone.com/refcardz/core-java-concurrency?chapter=1