共计 3088 个字符，预计需要花费 8 分钟才能阅读完成。
引言
在多线程环境下，通常我们使用 synchronized 关键字来保证线程安全。
大多数情况下，用 synchronized 关键字就足够了，但它也有一些缺点, 所以在 Java Concurrency 包中引入了 Lock API。从 Java 1.5 版开始在 java.util.concurrent.locks 包中提供了处理并发的 Concurrency API 的 Lock 锁接口和一些实现类来改进 Object 锁定机制。
Java Lock API 中的一些重要接口和类
Java Lock API 中的一些重要接口和类是：
锁(Lock)：这是 Lock API 的基本接口。它提供了 synchronized 关键字的所有功能，以及为锁定创建不同条件的其他方法，为线程等待锁定提供超时功能。一些重要的方法是 lock() 获取锁，unlock() 释放锁，tryLock() 等待锁定一段时间，newCondition() 创建条件等。
条件 (Condition)：条件对象类似于对象等待通知(Object wait-notify) 模型，具有创建不同等待集的附加功能。Condition 对象始终由 Lock 对象创建。一些重要的方法是 await()，类似于 Object.wait() 和 signal()，signalAll()，类似于 Object.notify() 和 Object.notifyAll() 方法。
读写锁(ReadWriteLock)：它包含一对关联的锁，一个用于只读操作，另一个用于写入。只要没有写入线程，读锁可以由多个读取线程同时保持。写锁是独占的。
重入锁(ReentrantLock)：这是最广泛使用的 Lock 接口实现类。此类以与 synchronized 关键字类似的方式实现 Lock 接口。除了 Lock 接口实现之外，ReentrantLock 还包含一些实用程序方法来获取持有锁的线程，等待获取锁线程等。
synchronized 块
synchronized 块本质上是可重入的，即如果一个线程锁定了监视对象，并且另一个同步块需要锁定在同一个监视对象上，则线程可以进入该代码块。我认为这就是类名是 ReentrantLock 的原因。让我们通过一个简单的例子来理解这个特性。
public class Test{
public synchronized foo(){
//do something
bar();
}
public synchronized bar(){
//do some more
}
}
如果一个线程进入 foo()，它就会锁定 Test 对象，所以当它尝试执行 bar() 方法时，允许该线程执行 bar() 方法，因为它已经在 Test 对象上持有锁，即与 synchronized(this) 效果是一样的。
Java Lock 示例 – Java 中的 ReentrantLock
现在让我们看一个简单的例子，我们将使用 Java Lock API 替换 synchronized 关键字。
假设我们有一个 Resource 类，其中包含一些操作，我们希望它是线程安全的，以及一些不需要线程安全的方法。
package com.journaldev.threads.lock;
public class Resource {
public void doSomething(){
//do some operation, DB read, write etc
}
public void doLogging(){
//logging, no need for thread safety
}
}
现在假设我们有一个 Runnable 类，我们将使用 Resource 方法。
package com.journaldev.threads.lock;
public class SynchronizedLockExample implements Runnable{
private Resource resource;
public SynchronizedLockExample(Resource r){
this.resource = r;
}
@Override
public void run() {
synchronized (resource) {
resource.doSomething();
}
resource.doLogging();
}
}
请注意，我使用 synchronized 块来获取 Resource 对象上的锁。我们可以在类中创建一个虚拟对象，并将其用于锁定的目的。
现在让我们看看我们如何使用 Java Lock API 并重写上面的程序而不使用 synchronized 关键字。我们将在 Java 中使用 ReentrantLock。
package com.journaldev.threads.lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ConcurrencyLockExample implements Runnable{
private Resource resource;
private Lock lock;
public ConcurrencyLockExample(Resource r){
this.resource = r;
this.lock = new ReentrantLock();
}
@Override
public void run() {
try {
if(lock.tryLock(10, TimeUnit.SECONDS)){
resource.doSomething();
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
//release lock
lock.unlock();
}
resource.doLogging();
}
}
正如你所看到的，我正在使用 tryLock() 方法来确保我的线程只等待一定的时间，如果它没有获得对象的锁定，它只是记录和退出。另一个要注意的重点是使用 try-finally 块来确保即使 doSomething() 方法调用抛出任何异常也会释放锁定。
Java Lock 与 synchronized 比较
基于以上细节和程序，我们可以很容易地得出 Java Lock 和同步之间的以下差异。
Java Lock API 为锁定提供了更多的可见性和选项，不像在线程可能最终无限期地等待锁定的同步，我们可以使用 tryLock() 来确保线程仅等待特定时间。
用同步关键字的代码更清晰，更易于维护，而使用 Lock，我们不得不尝试使用 try-finally 块来确保即使在 lock() 和 unlock() 方法调用之间抛出异常也会释放 Lock。
同步块或方法只能覆盖一种方法，而我们可以在一种方法中获取锁，并使用 Lock API 在另一种方法中释放它。
synchronized 关键字不提供公平性，而我们可以在创建 ReentrantLock 对象时将公平性设置为 true，以便最长等待的线程首先获得锁定。
我们可以为 Lock 创建不同的等待条件(Condition)，不同的线程可以针对不同的条件来 await()。
这就是 Java Lock 示例，Java 中的 ReentrantLock 以及使用 synchronized 关键字的比较分析。
作 者:
关于 Pankaj 如果你走得这么远，那就意味着你喜欢你正在读的东西。为什么不直接在 Google Plus，Facebook 或 Twitter 上与我联系。我很想直接听到你对我的文章的想法和意见。
最近我开始创建视频教程，所以请在 Youtube 上查看我的视频。