【并发基础】ReentrantLock详解(一)

本文主要是介绍【并发基础】ReentrantLock详解(一)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

简介

ReentrantLock重入锁，是实现Lock接口的一个类，也是在实际编程中使用频率很高的一个锁，支持重入性，表示能够对共享资源能够重复加锁，即当前线程获取该锁再次获取不会被阻塞。与此同时，ReentrantLock还支持公平锁和非公平锁两种方式。

数据结构

//自定义同步器，Sync为ReentrantLock的内部类，继承AbstractQueuedSynchronizer
private final Sync sync;//默认为非公平锁
public ReentrantLock() {sync = new NonfairSync();
}//可以指定公平策略
public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();
}

核心方法

lock()

public void lock() {sync.lock()
}

lock()获取锁，主要调用AQS的acquire(1)，此时可分为三种情况：

当前线程成功获取锁，该方法直接返回，设置state为1；
当前线程已经持有该锁，该方法直接返回，state加1，即重入次数加1；
锁被其他线程持有，则当前线程进入同步队列等待。

lockInterruptibly()

public void lockInterruptibly() throws InterruptedException {sync.acquireInterruptibly(1);
}

该方法和lock类似，只是响应中断，会抛出InterruptedException异常，需要上层调用者自行进行中断异常处理。

该方法直接调用AQS相应的方法实现。

tryLock()

public boolean tryLock() {return sync.nonfairTryAcquire(1);
}

tryLock()尝试获取锁，获取成功则返回true，获取失败则返回false，不会一直阻塞。另一点值得注意的是，该方法始终采用非公平策略，即使初始化时已经声明使用公平策略，也就是说，调用tryLock方法时，会立即尝试获取锁，无论是否还有没有其他线程正在等待。

该方法调用ReentrantLock自定义同步器Sync里面的方法。

tryLock(long timeout, TimeUnit unit)

public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

tryLock()方法有如下特性：

无法立即获取锁时，该方法会等待timeout时间；
当锁声明为公平锁时，该方法支持使用公平策略；
响应中断。

该方法直接调用AQS相应的方法实现。

unlock()

public void unlock() {sync.release(1);
}

unlock()方法会调用ReentrantLock的自定义同步器Sync的tryRelease方法，有如下三种情况：

如果当前线程持有锁，则state减1;
如果state为0时直接释放锁；
如果当前线程不持有锁，则抛出IllegalMonitorStateException异常。

newCondition()

public Condition newCondition() {return sync.newCondition();
}

Condition对象可以起到Object监视器方法（wait, notify, notifyAll）的作用，Object的监视器方法需要在同步方法或同步块中调用，而Condition的方法需要在获取锁之后调用，不同在于一个锁可以创建多个Condition对象，可以对不同线程进行不同的控制（个人理解为是对线程的分类），而synchronized则类似于只有一个Condition对象的Lock。

getHoldCount()

public int getHoldCount() {return sync.getHoldCount();
}

HoldCount记录当前线程持有该锁的次数，如果当前线程持有锁，则该值为state的值，否则为0。

Sync详解

Sync同步器使用AQS的state变量表示持有锁的线程在当前锁重入的数量，当state为0时，表示锁未被其他线程持有。

在ReentrantLock中，重入一次则数量+1。

nonfairTryAcquire(int)

nonfairTryAcquire(int)方法实现非公平的tryLock。

final boolean nonfairTryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();//state为0时，表示没有其他线程持有锁if (c == 0) {//修改state的值，并设置当前线程为该独占锁的持有者if (compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}}//如果当前线程已经持有该锁else if (current == getExclusiveOwnerThread()) {//更新state，state表示当前锁已被重入的数量int nextc = c + acquires;if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;
}

tryRelease(int)

需要持有锁的线程才能调用该方法，否则会抛出IllegalMonitorStateException异常。

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;
}

newCondition()

ReentrantLock的Condition实现为ConditionObject

final ConditionObject newCondition() {return new ConditionObject();
}

其他核心方法

//获取锁的持有者
final Thread getOwner() {return getState() == 0 ? null : getExclusiveOwnerThread();
}//HoldCount表示当前线程持有锁的数量
final int getHoldCount() {return isHeldExclusively() ? getState() : 0;
}//AQS的state用来判断锁是否已被锁定
final boolean isLocked() {return getState() != 0;
}//判断当前线程是否持有该锁
protected final boolean isHeldExclusively() {return getExclusiveOwnerThread() == Thread.currentThread();
}

NonfairSync（非公平同步器）

static final class NonfairSync extends Sync {private static final long serialVersionUID = 7316153563782823691L;final void lock() {//强制获取锁，如果锁未被锁定，也就是state为0，则下面操作返回true，当前线程获取锁//否则返回false，当前线程进入同步队列if (compareAndSetState(0, 1))setExclusiveOwnerThread(Thread.currentThread());elseacquire(1);}//调用父类Sync的nonfairTryAcquire方法获取锁protected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);}
}

FairSync（公平同步器）

static final class FairSync extends Sync {private static final long serialVersionUID = -3000897897090466540L;//直接调用AQS的acquire方法final void lock() {acquire(1);}protected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {//hasQueuedPredecessors判断当前线程是否是下一个可执行结点//非公平锁会直接尝试CAS更新state，但是公平锁需要当前结点是头结点才能使用CAS更新stateif (!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;}
}