ReentrantLock:
1.源码层面分析:
public class ReentrantLock implements Lock, java.io.Serializable { private static final long serialVersionUID = 7373984872572414699L; //实现同步逻辑的同步器，提供了所有锁相关的操作 private final Sync sync; //默认构造函数，提供了非公平锁 public ReentrantLock() { sync = new NonfairSync(); } /** * 根据策略（公平，非公平）来构建重入锁 * @param fair true表示采用公平锁，false表示采用非公平锁 */ public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); } //获取锁，获取成功则返回，否则阻塞获取线程直到获取成功 public void lock() { sync.lock(); } //获取锁，获取成功则返回，否则阻塞获取线程直到获取成功；并响应中断，也就是说获取线程被Thread.interrupt()中断后，该方法会抛出InterruptedException并返回。 public void lockInterruptibly() throws InterruptedException { sync.acquireInterruptibly(1); } /** * 尝试获取锁，不管成功，失败都立即返回，不会阻塞 * @return true表示获取成功，false表示失败 */ public boolean tryLock() { return sync.nonfairTryAcquire(1); } /** * 尝试获取锁，获取成功则返回，否则等待timeout时间返回 * @param timeout 等待获取锁的超时时间 * @param unit 时间单位 * @return true表示获取成功，false表示超时时间到达仍然获取失败 */ public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException { return sync.tryAcquireNanos(1, unit.toNanos(timeout)); } //释放锁，该方法不会阻塞 public void unlock() { sync.release(1); } /** * 获取一个条件对象 * @return 条件对象 */ public Condition newCondition() { return sync.newCondition(); }
2.Sync内部类:
//同步抽象类，基于AQS实现 abstract static class Sync extends AbstractQueuedSynchronizer { private static final long serialVersionUID = -5179523762034025860L; //具体由子类NoFairSync，FairSync实现 abstract void lock(); /** * 非公平的方式尝试获取资源 * @param acquires 资源个数 * @return true表示获取成功，false获取失败 */ final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); //获取资源状态，volatile读 int c = getState(); //0表示初始状态或者锁释放状态，可以直接获取资源 if (c == 0) { //CAS判断资源获取是否成功 if (compareAndSetState(0, acquires)) { //获取成功则设置当前线程为资源（锁）的持有线程 setExclusiveOwnerThread(current); return true; } } //如果当前线程为持有锁的线程，可以直接操作资源，体现重入性 else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } //其他状态说明资源已被其他占用无法获取 return false; } /** * 尝试释放资源 * @param releases 资源个数 * @return true表示释放成功，false释放失败 */ protected final boolean tryRelease(int releases) { int c = getState() - releases; //如果当前线程不为持有资源的线程，则抛出异常 if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; //如果释放后，资源的个数为0表示释放成功 if (c == 0) { free = true; //设置资源的独占线程为null，此时没有线程占用资源 setExclusiveOwnerThread(null); } setState(c); return free; } /** * 判断当前线程是否持有资源 * @return true表示是，false表示否 */ protected final boolean isHeldExclusively() { return getExclusiveOwnerThread() == Thread.currentThread(); } /** * 获取条件对象 * @return 新的条件对象 */ final ConditionObject newCondition() { return new ConditionObject(); } /** * 获取持有资源的线程 * @return 持有资源的线程 */ final Thread getOwner() { return getState() == 0 ? null : getExclusiveOwnerThread(); } /** * 获取持有资源的个数 * @return 持有资源的个数 */ final int getHoldCount() { return isHeldExclusively() ? getState() : 0; } /** * 获取资源是否被线程占用 * @return true表示是，false否 */ final boolean isLocked() { return getState() != 0; } }
ReentrantLock内部基于Sync提供了非公平锁和公平锁的实现。
3.非公平锁
//非公平锁继承自Sync static final class NonfairSync extends Sync { private static final long serialVersionUID = 7316153563782823691L; /** * 非公平锁提供的锁定方法 */ final void lock() { //先尝试CAS获取操作，获取成功则设置当前线程为资源持有线程并返回 if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else //获取失败则进入AQS的acquire逻辑，排队获取资源 acquire(1); } /** * 非公平的方法尝试获取资源，AQS对外提供的需要实现方法 * @param acquires资源个数 * @return true表示是，false否 */ protected final boolean tryAcquire(int acquires) { //用Sync类的非公平方式尝试获取资源 return nonfairTryAcquire(acquires); } }
4.公平锁:
static final class FairSync extends Sync { private static final long serialVersionUID = -3000897897090466540L; /** * 公平锁提供的锁定方法 */ final void lock() { //排队获取资源，体现公平性 acquire(1); } /** * 公平的方式尝试获取资源 * @param acquires资源个数 * @return true表示是，false否 */ protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); //0表示当前可以直接获取资源 if (c == 0) { //先判断当前有没有线程排队获取，如果没有当前线程才能获取，体现公平性 if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } //如果当前线程本来就持有资源，可以继续操作资源，体现重入性 else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } //其他情况获取失败，让线程排队获取 return false; } }
5.**总结：**非公平主要体现在资源获取时，如果获取线程发现当前资源可以获取成功（其他线程释放了资源）那就直接获取返回，而此时可能有其他线程先于当前线程在排队获取，那么对于这部分线程来说是“不公平”的，没有体现先到先得的原则。反之，就是公平锁，先排队的线程先获取锁，不存在插队的情况，体现了公平性，所以叫公平锁。
6.ReentrantLock默认使用非公平方式提供锁的获取和释放，可以看到相比公平模式，非公平模式获取锁的效率更高，因为在非公平模式下如果能够获取锁成功则线程不需要再排队，而在公平模式下，所有线程都必须排队获取锁，所以从当前获取锁的线程的角度非公平模式效率更高。还有一个地方需要说明的是：ReentrantLock是可重入锁，也就是说同一个线程获取锁后可再次重复获取锁无需阻塞。
7.典型应用场景:
class X { private final ReentrantLock lock = new ReentrantLock(); private Condition condition = lock.newCondition(); public void m() { lock.lock(); // 获取锁 try { try { //必须先获取锁才能执行条件等待，其他线程需要执行condition.signal()方法，来唤醒等待线程 condition.await(); } catch (InterruptedException e) { e.printStackTrace(); } // 执行具体业务方法 } finally { lock.unlock() //释放锁，必须在finally块中，防止发生异常时未执行释放锁操作，导致其他线程无法获取锁 } } }}
