典型回答

synchronized 是 Java 内建的同步机制，所以也有人称其为 Intrinsic Locking，它提供了互斥的语义和可见性，当一个线程已经获取当前锁时，其他试图获取的线程只能等待或者阻塞在那里。

在 Java 5 以前，synchronized 是仅有的同步手段，在代码中， synchronized 可以用来修饰方法，也可以使用在特定的代码块儿上，本质上 synchronized 方法等同于把方法全部语句用 synchronized 块包起来。

ReentrantLock，通常翻译为再入锁，是 Java 5 提供的锁实现，它的语义和 synchronized 基本相同。再入锁通过代码直接调用 lock() 方法获取，代码书写也更加灵活。与此同时，ReentrantLock 提供了很多实用的方法，能够实现很多 synchronized 无法做到的细节控制，比如可以控制 fairness，也就是公平性，或者利用定义条件等。但是，编码中也需要注意，必须要明确调用 unlock() 方法释放，不然就会一直持有该锁。

synchronized 和 ReentrantLock 的性能不能一概而论，早期版本 synchronized 在很多场景下性能相差较大，在后续版本进行了较多改进，在低竞争场景中表现可能优于 ReentrantLock。

考点分析

  • 理解什么是线程安全
  • synchronized、ReentrantLock 等机制的基本使用与案例

更进一步，你还需要：

  • 掌握 synchronized、ReentrantLock 底层实现；
  • 理解锁膨胀、降级；
  • 理解偏斜锁、自旋锁、轻量级锁、重量级锁等概念。
  • 掌握并发包中 java.util.concurrent.lock 各种不同实现和案例分析。

知识扩展

线程安全是一个多线程环境下正确性的概念，也就是保证多线程环境下共享的、可修改的状态的正确性，这里的状态反映在程序中其实可以看作是数据。

线程安全需要保证几个基本特性：

  • 原子性，简单说就是相关操作不会中途被其他线程干扰，一般通过同步机制实现。
  • 可见性，是一个线程修改了某个共享变量，其状态能够立即被其他线程知晓，通常被解释为将线程本地状态反映到主内存上，volatile 就是负责保证可见性的。
  • 有序性，是保证线程内串行语义，避免指令重排等。

利用 monitorenter/monitorexit 对实现了同步的语义：

  2. 11: astore_1
  3. 12: monitorenter
  4. 13: aload_0
  5. 14: dup
  6. 15: getfield    #2                // Field sharedState:I
  7. 18: dup_x1
  8. …
  9. 56: monitorexit

ReentrantLock
什么是再入？它是表示当一个线程试图获取一个它已经获取的锁时，这个获取动作就自动成功，这是对锁获取粒度的一个概念，也就是锁的持有是以线程为单位而不是基于调用次数。Java 锁实现强调再入性是为了和 pthread 的行为进行区分。再入锁可以设置公平性（fairness），我们可在创建再入锁时选择是否是公平的。
ReentrantLock fairLock = new ReentrantLock(true);

这里所谓的公平性是指在竞争场景中，当公平性为真时，会倾向于将锁赋予等待时间最久的线程。公平性是减少线程“饥饿”（个别线程长期等待锁，但始终无法获取）情况发生的一个办法。

只有当你的程序确实有公平性需要的时候，才有必要指定它。

ReentrantLock 相比 synchronized，因为可以像普通对象一样使用，所以可以利用其提供的各种便利方法，进行精细的同步操作，甚至是实现 synchronized 难以表达的用例，如：

  • 带超时的获取锁尝试
  • 可以判断是否有线程，或者某个特定线程，在排队等待获取锁
  • 可以响应中断请求

特别想强调条件变量（java.util.concurrent.Condition），如果说 ReentrantLock 是 synchronized 的替代选择，Condition 则是将 wait、notify、notifyAll 等操作转化为相应的对象，将复杂而晦涩的同步操作转变为直观可控的对象行为。

条件变量最为典型的应用场景就是标准类库中的 ArrayBlockingQueue 等。我们参考下面的源码，首先，通过再入锁获取条件变量：

  2. /** Condition for waiting takes */
  3. private final Condition notEmpty;
  5. /** Condition for waiting puts */
  6. private final Condition notFull;
  8. public ArrayBlockingQueue(int capacity, boolean fair) {
  9.   if (capacity <= 0)
  10.       throw new IllegalArgumentException();
  11.   this.items = new Object[capacity];
  12.   lock = new ReentrantLock(fair);
  13.   notEmpty = lock.newCondition();
  14.   notFull =  lock.newCondition();
  15. }

两个条件变量是从同一再入锁创建出来，然后使用在特定操作中，如下面的 take 方法，判断和等待条件满足：

  2. public E take() throws InterruptedException {
  3.   final ReentrantLock lock = this.lock;
  4.   lock.lockInterruptibly();
  5.   try {
  6.       while (count == 0)
  7.           notEmpty.await();
  8.       return dequeue();
  9.   } finally {
  10.       lock.unlock();
  11.   }
  12. }

当队列为空时，试图 take 的线程的正确行为应该是等待入队发生，而不是直接返回，这是 BlockingQueue 的语义，使用条件 notEmpty 就可以优雅地实现这一逻辑。那么，怎么保证入队触发后续 take 操作呢？请看 enqueue 实现：

  2. private void enqueue(E e) {
  3.   // assert lock.isHeldByCurrentThread();
  4.   // assert lock.getHoldCount() == 1;
  5.   // assert items[putIndex] == null;
  6.   final Object[] items = this.items;
  7.   items[putIndex] = e;
  8.   if (++putIndex == items.length) putIndex = 0;
  9.   count++;
  10.   notEmpty.signal(); // 通知等待的线程，非空条件已经满足
  11. }

通过 signal/await 的组合，完成了条件判断和通知等待线程，非常顺畅就完成了状态流转。注意，signal 和 await 成对调用非常重要，不然假设只有 await 动作，线程会一直等待直到被打断（interrupt）。