【Java 并发编程】ReentrantLock

合集 - Java(25)

1.Java 集合2023-10-102.Java IO2024-01-063.JVM 对象的创建2023-10-274.Java 线程基础2023-10-265.Java Hotspot G1 GC 原理2023-10-286.Java 中的代理模式2023-10-187.JVM 的内存结构2023-10-178.【JVM】Java 的类加载机制2023-10-179.Java Lambda 表达式2024-01-0510.Java NIO 介绍2023-11-0711.Java 垃圾回收机制2023-10-2812.【Java 并发编程】Condition2023-10-1713.【Java 并发编程】ThreadLocal2023-10-17

14.【Java 并发编程】ReentrantLock2023-10-17

15.【Java 并发编程】synchronized2023-10-1716.【Java 并发编程】LockSupport2023-10-1717.【Java 并发编程】AQS2023-10-1618.【Java 并发编程】线程池2023-10-1219.【Java 并发编程】锁和JUC2023-10-1120.Java 基础2023-10-0821.【Java 并发编程】并发容器2023-10-0822.Java 内存模型2023-09-2023.【Java 并发】线程同步2024-01-0624.【Java 并发】同步器2024-01-0625.【Java 并发编程】synchronized 加锁的四种状态与升级过程2024-01-07

收起

目录

• ReentrantLock
  • ReentrantLock 特性概览
• 源码分析
  • 抽象同步器：Sync
    • 非公平同步器：NonfairSync
    • 公平同步器：FairSync
  • 小结

ReentrantLock

ReentrantLock 是一个可重入的互斥锁，又被称为“独占锁”。

ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。

ReentrantLock 锁在同一个时间点只能被一个线程锁持有；而可重入的意思是，ReentrantLock 锁，可以被单个线程多次获取。

ReentrantLock 特性概览

ReentrantLock 意思为可重入锁，指的是一个线程能够对一个临界资源重复加锁。这里，我们先将 ReentrantLock 跟常用的 Synchronized 进行比较：

特性	ReentrantLock	Synchronized
锁实现机制	基于AQS	监视器模式
灵活性	支持响应中断、超时、尝试获取锁	不灵活
释放形式	必须显式调用 unlock() 释放锁	自动释放监视器
锁类型	公平锁、非公平锁	非公平锁
条件队列	可关联多个条件队列	关联一个条件队列
是否可重入	是	是

【示例】

public class LockTest {
    public void test () throws Exception {
        // 1.初始化选择公平锁、非公平锁
        ReentrantLock lock = new ReentrantLock(true);
        // 2.可用于代码块
        lock.lock();
        try {
            try {
                // 3.支持多种加锁方式，比较灵活; 具有可重入特性
                if(lock.tryLock(100, TimeUnit.MILLISECONDS)){ }
            } finally {
                // 4.手动释放锁
                lock.unlock();
            }
        } finally {
            lock.unlock();
        }
    }
}

源码分析

ReentrantLock 总共有三个内部类Sync、NonfairSync、FairSync。其源码如下：

public class ReentrantLock implements Lock, java.io.Serializable {
   private final Sync sync;
   abstract static class Sync extends AbstractQueuedSynchronizer {
      ...
   }
 
   static final class FairSync extends Sync {
      ...
   }
 
   static final class NonfairSync extends Sync {
      ...
   }
   ...
}

NonfairSync 与 FairSync 类继承自 Sync 类，Sync 类继承自 AbstractQueuedSynchronizer 抽象类：

抽象同步器：Sync

Sync 类的方法和作用如下：

方法	作用
void lock()	锁定，抽象方法
boolean nonfairTryAcquire(int acquires)	非公平地方式锁定
boolean tryRelease(int releases)	尝试在共享模式下获取对象状态
boolean isHeldExclusively()	判断资源是否被当前线程占有
ConditionObject newCondition()	新生成一个条件
Thread getOwner()	返回占有资源的线程
int getHoldCount()	返回状态
boolean isLocked()	资源是否被占用
void readObject(java.io.ObjectInputStream s)	自定义反序列化逻辑

部分源码如下：

public class ReentrantLock implements Lock, java.io.Serializable {
 
   abstract static class Sync extends AbstractQueuedSynchronizer {
      ...
      abstract void lock();
 
      // 非公平方式获取
      final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) { // 抢占式，CAS 方式设置状态成功，状态 0 表示锁没有被占用
                    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;
        }
 
        // 试图在共享模式下获取对象状态，此方法应该查询是否允许它在共享模式下获取对象状态，如果允许，则获取它
        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread()) // 当前线程不为独占线程
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }
   }
   ...
}

具体的流程：

非公平同步器：NonfairSync

NonfairSync 类继承了 Sync 类，表示采用非公平策略获取锁，实现了 Sync 类中抽象的 lock 方法，源码如下:

public class ReentrantLock implements Lock, java.io.Serializable {
 
   static final class NonfairSync extends Sync {
      final void lock() {
            if (compareAndSetState(0, 1)) // 抢占式，比较并设置状态成功，状态0表示锁没有被占用
                setExclusiveOwnerThread(Thread.currentThread()); // 把当前线程设置独占了锁
            else // 锁已经被占用，或者set失败
                acquire(1); // 以独占模式获取对象，忽略中断
        }
 
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
   }
   ...
}

每一次 lock 调用，都会尝试获取锁，然而它并不会按照公平等待的原则进行等待，而是抢占式地获取锁。

如果线程抢占失败，就会调用 acquire(1)，进而通过 tryAcquire() 获取锁。在这种情况下，如果获取锁失败，就会调用 addWaiter() 加入到等待队列中去。

公平同步器：FairSync

FairSync 类也继承了 Sync 类，表示采用公平策略获取锁，其实现了 Sync 类中的抽象 lock 方法，源码如下:

public class ReentrantLock implements Lock, java.io.Serializable {
    static final class FairSync extends Sync {
        final void lock() {
            acquire(1); // 以独占模式获取对象，忽略中断
        }
 
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                // 不存在已经等待更久的线程并且比较并且设置状态成功
                if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current); // 设置当前线程独占
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) { // 状态不为0，即资源已经被线程占据
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }
    ...
}

公平锁 FairSync 的 lock 方法，使用了 AQS 的默认实现，当资源空闲时，它总是会先判断 sync 队列是否有等待时间更长的线程，如果存在，则将该线程加入到等待队列的尾部，实现了公平获取原则。

小结

在 ReentrantLock 里面，不管是公平锁（FairSync#tryAcquire），还是非公平锁（Sync#nonfairTryAcquire），都有一段通过 state 控制重入的类似逻辑。其中，state 这个字段主要的作用：

• state 初始化的时候为 0，表示没有任何线程持有锁。

• 当有线程持有该锁时，值就会在原来的基础上 +1，同一个线程多次获得锁是，就会多次 +1，这里就是可重入的概念。

• 解锁也是对这个字段 -1，一直到 0，此线程对锁释放。

---

参考：

• JUC锁: ReentrantLock详解

• 从ReentrantLock的实现看AQS的原理及应用