ReentrantLock源码阅读

最新推荐文章于 2026-06-29 16:52:08 发布

原创最新推荐文章于 2026-06-29 16:52:08 发布 · 588 阅读

14 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

java基础源码阅读

一、 ReentrantLock概念

ReentrantLock，是java并发编程中提供的一种高级同步机制。实现了lock接口和Serializable接口，基于AQS（AbstractQueuedSynchronizer）实现了锁的功能。是一种可重入的互斥锁，支持公平锁和非公平锁的选择。

二、相关属性

ReentrantLock 的实现是基于内部的sync 的属性实现，而sync 继承了AbstractQueuedSynchronizer，其核心属性有以下部分。

1、 private volatile int state：线程获取锁时候需要将state从0改为1，state为0代表没有线程持有锁，state大于0 代表某个线程正持有这把锁，state的值代表重入次数。

2、 private transient volatile Node head: 同步列表的头部指向下一个线程封装成的Node对象

3、 private transient volatile Node tail: 同步列表尾部元素，后期竞争失败的元素的prev指向tail,tail赋值为新的node.

三、构造函数

1、无参构造函数生成非公平锁

public ReentrantLock() {
        sync = new NonfairSync();
    }

2、有参构造函数，根据传入值生成公平锁或非公平锁

 public ReentrantLock(boolean fair) {
         //传入参数为true为公平锁 false 非公平锁
        sync = fair ? new FairSync() : new NonfairSync();
    }

3、构造函数中的两个内部类(FairSync与NonFairSync)都继承了Sync,两个主要区别的两个方法lock()和tryAcquire() （两个的tryAcquire的逻辑基本是一致的）
FairSync的 lock()

final void lock() {
            //直接进入 acquire
          acquire(1);
        }

NonFairSync的Lock

final void lock() {
            //直接尝试修改state获取锁
            //获取成功设置锁持有线程为当前线程
            //获取失败进入 acquire
            if (compareAndSetState(0, 1))            setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

Sync的 acquire()

 public final void acquire(int arg) {
        //tryAcquire 成功直接返回
        //
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
protected final boolean tryAcquire(int acquires) {
            //获取当前线程和state的值
            final Thread current = Thread.currentThread();
            int c = getState();
            // state 为0 去竞争锁，设置锁拥有线程
            if (c == 0) {
                // hasQueuedPredecessors 这个是公平锁特有的
                //判断当前线程是否需要排队，也就是同步队列是否存在线程排队，存在则需要排队，不存在，不需要排队直接尝试获取锁。
                // 非公平锁直接竞争锁
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            // state不为0 判断当前线程是否为锁拥有线程
            // 是 锁重入
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

四、常见方法

1、 lock方法获取锁

 public void lock() {
        sync.lock();
    }
 public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                //判断node的前一个元素是否是head
                //如果是去获取锁，获取成功设置head为当前node
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                //判断线程是否被挂起进入等待
                if (shouldParkAfterFailedAcquire(p, node) &&
                    //挂起当前线程并检查线程是否被中断
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                // 取消等待
                cancelAcquire(node);
        }
    }
   private Node addWaiter(Node mode) {
       //将线程封装成Node
        Node node = new Node(Thread.currentThread(), mode);
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            //将新生成Node放在同步队列末尾
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }      2、  tryLock 获取锁 
        tryLock 的源码说明它只会获取一次锁，获取成功返回true，获取失败直接返回false,不会进去等待队列

public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }
final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                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;
        }
      3、  tryLock(Long timeOut ,TimeUnit unit)获取锁，超时失败，不进入等待队列。
      4、  unLock() 释放锁，并唤醒等待队列后续线程

public void unlock() {
        sync.release(1);
    }
public final boolean release(int arg) {
        //释放锁
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                //唤醒后续线程
                unparkSuccessor(h);
            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;
                //设置锁拥有线程为null
                setExclusiveOwnerThread(null);
            }
            //修改state值
            setState(c);
            return free;
        }
      5、  getHoldCount 获取当前线程保持此锁的次数。