大学生建设网站对网站进行seo优化
ReentrantLock源码解读
在讲ReentrantLock之前我们先看一下Lock接口里的方法
Lock接口中的方法
lock()方法
void lock(); //直接加锁,如果加锁失败什么也不返回
lockInterruptibly()方法
void lockInterruptibly() throws InterruptedException;
lockInterruptibly()方法能够中断等待获取锁的线程。当两个线程同时通过lock.lockInterruptibly()获取某个锁时，假若此时线程A获取到了锁，而线程B只有等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。
tryLock()
boolean tryLock(); //直接加锁,如果加锁失败返回false
tryLock(long time, TimeUnit unit)
boolean tryLock(long time, TimeUnit unit) throws InterruptedException; // 尝试获取锁，如果没获取到锁，就等待一段时间，这段时间内还没获取到锁就返回false
unlock()方法
void unlock();//释放锁
newCondition()
Condition newCondition();// 条件锁
以上就是Lock接口中的方法，接下来我们看一下ReentrantLock的实现代码。
ReentrantLock的内部类
首先是ReentrantLock的三个内部类：Sync、NonfairSync、FairSync，其中NonfairSync类和FairSync类是继承Sync类
Sync类
首先Sync是一个静态的抽象类，下面我们看一下它的内部方法。
lock()
abstract void lock(); //抽象方法由子类实现
nonfairTryAcquire()
final boolean nonfairTryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {//判断当前是否有线程持有锁if (compareAndSetState(0, acquires)) {//使用CAS尝试加锁setExclusiveOwnerThread(current);return true;}}else if (current == getExclusiveOwnerThread()) {//判断当前持有锁的线程是否是自己int nextc = c + acquires;if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc); //锁重入了，修改state的值return true;}return false;
}
tryRelease()
释放锁的方法
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;
}
isHeldExclusively()
判断锁是否是当前线程持有
protected final boolean isHeldExclusively() {// While we must in general read state before owner,// we don't need to do so to check if current thread is ownerreturn getExclusiveOwnerThread() == Thread.currentThread();
}
newCondition()
// 条件锁
final ConditionObject newCondition() {return new ConditionObject();
}
getOwner()
返回当前持有锁的线程，如果没有则返回null
final Thread getOwner() {return getState() == 0 ? null : getExclusiveOwnerThread();
}
getHoldCount()
当前线程持有此锁的次数，如果当前线程不持有此锁，则为零
final int getHoldCount() {return isHeldExclusively() ? getState() : 0;
}
NonfairSync类
NonfairSync是非公平锁的实现类，继承了Sync类。
lock()
加锁方法，因为是非公平锁所以在加锁的时候会先去尝试加锁，如果加锁失败则调用acquire()方法放入队列排队
final void lock() {if (compareAndSetState(0, 1))setExclusiveOwnerThread(Thread.currentThread());elseacquire(1);
}
tryAcquire()
这里是调用父类的方法nonfairTryAcquire
protected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);
}
FairSync类
FairSync公平锁的实现类
lock()
加锁方法
final void lock() {acquire(1);//调用父类的方法加锁
}
tryAcquire()
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()) {//判断当前持有锁的线程是否是自己int nextc = c + acquires;if (nextc < 0)throw new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}
}
以上就是ReentrantLock的内部类了，接下来看一下构造方法
ReentrantLock的构造方法
无参构造方法
无参构造方法默认使用非公平锁
public ReentrantLock() {sync = new NonfairSync();
}
有参构造
传入参数为true时，是公平锁，false是非公平锁
public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();
}
ReentrantLock的其他方法
其他方法的调用主要主要看ReentrantLock使用的是公平锁还是非公平锁，这里就不一一介绍了；关于ReentrantLock的锁的实现还涉及到了AbstractQueuedSynchronizer、AbstractOwnableSynchronizer这两个类，这些我们后面再继续分析。