ReentrantLock （公平锁、非公平锁）之非公平锁的实现

GDCY

已于 2022-07-14 14:46:13 修改

阅读量501

点赞数

文章标签： java

于 2022-07-14 14:43:07 首次发布

本文链接：https://blog.csdn.net/m0_50926448/article/details/125783755

版权

1、在了解ReentrantLock之前先了解几个概念

ReentrantLock是可重入锁：线程获取锁的时候，如果已经获取锁的线程就是当前线程的话，则此线程直接再次获取成功。由于锁会被获取n次，则在释放锁的时候也要释放n次，才算释放成功。基于内部类Sync属性state（继承AQS的state）进行统计。
ReentrantLock实现了公平锁与非公平锁：ReentrantLock在构造函数中提供了是否公平锁的初始化方法，默认是非公平锁。非公平锁的效率要远远高于公平锁，一般我们没有特殊需求的话都是用非公平锁。ReentrantLock内部类有抽象类Sync（Sync 继承抽象类AQS），FairSync，NonfairSync(FairSync，NonfairSync继承Sync实现)。用于实现公平锁与非公平锁。
```
public ReentrantLock() {
    sync = new NonfairSync();
}
/**
 * Creates an instance of {@code ReentrantLock} with the
 * given fairness policy.
 *
 * @param fair {@code true} if this lock should use a fair ordering policy
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}
```
2、非公平锁实现

我们从最常用的lock方法入手：

public void lock() {
    sync.lock();//sync称作为同步器，实际上就是一个内部抽象类。根据不同的继承类，实现公平与非公平锁的lock()方法
}

//非公平锁实现lock()
final void lock() {
    if (compareAndSetState(0, 1))//通过native方法实现state的修改预期是0，改为1(通过对象属性的相对内存偏移量修改值)，体现非公平性
        setExclusiveOwnerThread(Thread.currentThread());//上面如果修改成功代表抢占锁成功，将当前线程设为锁的拥有者
    else//代表锁被其他线程持有
        acquire(1);
}

//接上面acquire(1)
public final void acquire(int arg) {
     if (!tryAcquire(arg) &&//再次尝试获取锁
         acquireQueued(addWaiter(Node.EXCLUSIVE), arg))//tryAcquire(arg)未获取锁，则加入队列
         selfInterrupt();//中断当前线程
 }

//接上面tryAcquire(arg)
  final boolean nonfairTryAcquire(int acquires) {
       final Thread current = Thread.currentThread();
            int c = getState();//获取当前的重入次数（0代表当前还没线程持有锁，=1代表有线程持有锁，>1代表重入次数）
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {//修改state为1
                    setExclusiveOwnerThread(current);//抢到锁，保存当前锁持有的线程
                    return true;//代表获取锁成功
                }
            }
            else if (current == getExclusiveOwnerThread()) {//判断当前线程是不是锁的持有者，如果是就可重入
                int nextc = c + acquires;//state+1
                if (nextc < 0) // 
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);//state+1
                return true;//获取锁成功
            }
            return false;//如果上述条件都不满足就代表获取锁失败
  }

//接上面addWaiter(Node.EXCLUSIVE)，Node.EXCLUSIVE代表独占模式
private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);//新建当前线程信息为一个节点
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;//获取队列尾节点
        if (pred != null) {
            node.prev = pred;//如果队列有尾部那将新建节点放在尾节点后面排队
            if (compareAndSetTail(pred, node)) {//将aqs的尾节点替代为新建的节点
                pred.next = node;//之前的尾节点的下指针指向新建节点
                return node;
            }
        }
        enq(node);//此方法是如果此时没有队列，需要先建头尾节点再把新建节点加入队列
        return node;
    }

//接enq(node) node = new Node(Thread.currentThread(), mode)，mode = Node.EXCLUSIVE
private Node enq(final Node node) {
        for (;;) { //第一次循环如果没有队列就创建队列，那第二次循环将新建节点加入队列中。如果第一次循环有队列，就直接加入
            Node t = tail;
            if (t == null) { // Must initialize   //判断队列有无队列
                if (compareAndSetHead(new Node())) //创建队列
                    tail = head;
            } else {
                node.prev = t; //新建节点的prev指向tail节点
                if (compareAndSetTail(t, node)) {//设置aqs的尾节点为新建节点
                    t.next = node; //之前尾节点的next指向新建节点
                    return t;
                }
            }
        }
    }

总结：从上面源码可以看出，非公平锁线程在获取锁的时候直接一来就去尝试获取锁（体现非公平性），如果没获取到锁就进入acquice(1)方法，后续又一次尝试获取（!tryAcquice（1）方法），如果还没获取到就直接加入队列中阻塞线程。