深究ReentrantLock源码及其使用方法
1.先附上ReentrantLock类的源码，然后再进行一行一行分析
/*jadclipse*/// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) radix(10) lradix(10)
package java.util.concurrent.locks;
import java.io.*;
import java.util.Collection;
import java.util.concurrent.TimeUnit;
// Referenced classes of package java.util.concurrent.locks:
// AbstractQueuedSynchronizer, Lock, Condition
//在ReentrantLock类中有三个内部类，分别是FairSync、NoFairSync、Sync；
//其中FairSync和NoFairSync是静态内部类、Sync是抽象内部类
public class ReentrantLock
implements Lock, Serializable
{
//该类是公平锁的
static final class FairSync extends Sync
{
//锁方法
final void lock()
{
//以独占模式获取，忽略中断。 通过调用至少一次tryAcquire(int)实现，成功返回。 否则线程排队，可能会重复阻塞和解除阻塞，直到成功才调用tryAcquire(int)
acquire(1);
}
//尝试以独占模式获取。 该方法应该查询对象的状态是否允许以独占模式获取，如果是，则获取它。 该方法总是由执行获取的线程调用。 如果此方法报告失败，则获取方法可能将线程排队（如果尚未排队），直到被其他线程释放为止
protected final boolean tryAcquire(int i)
{
//得到当前的线程
Thread thread = Thread.currentThread();
//获取线程状态
int j = getState();
if(j == 0)
{
//进行CAS，如果成功则独占成功，然后返回true
if(!hasQueuedPredecessors() && compareAndSetState(0, i))
{
setExclusiveOwnerThread(thread);
return true;
}
} else if(thread == getExclusiveOwnerThread())//如果当前的线程就是本身，则更新线程状态
{
int k = j + i;
if(k < 0)
{
throw new Error("Maximum lock count exceeded");
} else
{
setState(k);
return true;
}
}
return false;
}
private static final long serialVersionUID = -3000897897090466540L;
FairSync()
{
}
}
static final class NonfairSync extends Sync
{
final void lock()
{
if(compareAndSetState(0, 1))//表示如果当前的状态state为0时，把state设为1，并返回true，然后把当前线程加到等待的线程队列中；如果返回false，则调用acquire(1)方法。
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int i)
{
return nonfairTryAcquire(i);
}
private static final long serialVersionUID = 7316153563782823691L;
NonfairSync()
{
}
}
static abstract class Sync extends AbstractQueuedSynchronizer
{
abstract void lock();
final boolean nonfairTryAcquire(int i)
{
Thread thread = Thread.currentThread();
int j = getState();
if(j == 0)
{
if(compareAndSetState(0, i))
{
setExclusiveOwnerThread(thread);
return true;
}
} else
if(thread == getExclusiveOwnerThread())
{
int k = j + i;
if(k < 0)
{
throw new Error("Maximum lock count exceeded");
} else
{
setState(k);
return true;
}
}
return false;
}
protected final boolean tryRelease(int i)
{
int j = getState() - i;
if(Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean flag = false;
if(j == 0)
{
flag = true;
setExclusiveOwnerThread(null);
}
setState(j);
return flag;
}
protected final boolean isHeldExclusively()
{
return getExclusiveOwnerThread() == Thread.currentThread();
}
final AbstractQueuedSynchronizer.ConditionObject newCondition()
{
return new AbstractQueuedSynchronizer.ConditionObject(this);
}
final Thread getOwner()
{
return getState() != 0 ? getExclusiveOwnerThread() : null;
}
final int getHoldCount()
{
return isHeldExclusively() ? getState() : 0;
}
final boolean isLocked()
{
return getState() != 0;
}
private void readObject(ObjectInputStream objectinputstream)
throws IOException, ClassNotFoundException
{
objectinputstream.defaultReadObject();
setState(0);
}
private static final long serialVersionUID = -5179523762034025860L;
Sync()
{
}
}
public ReentrantLock()
{
sync = new NonfairSync();
}
public ReentrantLock(boolean flag)
{
sync = ((Sync) (flag ? ((Sync) (new FairSync())) : ((Sync) (new NonfairSync()))));
}
public void lock()
{
sync.lock();
}
public void lockInterruptibly()
throws InterruptedException
{
sync.acquireInterruptibly(1);
}
public boolean tryLock()
{
return sync.nonfairTryAcquire(1);
}
public boolean tryLock(long l, TimeUnit timeunit)
throws InterruptedException
{
return sync.tryAcquireNanos(1, timeunit.toNanos(l));
}
public void unlock()
{
sync.release(1);
}
public Condition newCondition()
{
return sync.newCondition();
}
public int getHoldCount()
{
return sync.getHoldCount();
}
public boolean isHeldByCurrentThread()
{
return sync.isHeldExclusively();
}
public boolean isLocked()
{
return sync.isLocked();
}
public final boolean isFair()
{
return sync instanceof FairSync;
}
protected Thread getOwner()
{
return sync.getOwner();
}
public final boolean hasQueuedThreads()
{
return sync.hasQueuedThreads();
}
public final boolean hasQueuedThread(Thread thread)
{
return sync.isQueued(thread);
}
public final int getQueueLength()
{
return sync.getQueueLength();
}
protected Collection getQueuedThreads()
{
return sync.getQueuedThreads();
}
public boolean hasWaiters(Condition condition)
{
if(condition == null)
throw new NullPointerException();
if(!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
else
return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
}
public int getWaitQueueLength(Condition condition)
{
if(condition == null)
throw new NullPointerException();
if(!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
else
return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
}
protected Collection getWaitingThreads(Condition condition)
{
if(condition == null)
throw new NullPointerException();
if(!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
else
return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
}
public String toString()
{
Thread thread = sync.getOwner();
return (new StringBuilder()).append(super.toString()).append(thread != null ? (new StringBuilder()).append("[Locked by thread ").append(thread.getName()).append("]").toString() : "[Unlocked]").toString();
}
private static final long serialVersionUID = 7373984872572414699L;
private final Sync sync;
}
/*
DECOMPILATION REPORT
Decompiled from: C:\Program Files\Java\jre1.8.0_151\lib\rt.jar
Total time: 386 ms
Jad reported messages/errors:
Exit status: 0
Caught exceptions:
*/
2.源码分析(从ReentrantLock如何创建开始深究)
public ReentrantLock()
{
sync = new NonfairSync();
}
public ReentrantLock(boolean flag)
{
sync = ((Sync) (flag ? ((Sync) (new FairSync())) : ((Sync) (new NonfairSync()))));
}
通过上面代码，我们能够知道ReentrantLock有两个构造函数，一个是ReentrantLock()、另一个是RenntrantLock(boolean flag)
从中我们就能发现，ReentrantLock具有两种模式，一种是公平锁、另一种是非公平锁，因此我们使用时能够根据自身的需求进行创建不同模式的锁；
创建方式如下：
两种非公平锁创建方式：
ReentrantLock Nofairlock = new ReentrantLock();
ReentrantLock Nofairlock1 = new ReentrantLock(false);
创建公平锁
ReentrantLock fairlock = new ReentrantLock();
从ReentrantLock 的构造函数中，我们能够发现FairSync和NonfairSync两个静态内部类，我们先对NonfairSync（非公平锁）进行分析
static final class NonfairSync extends Sync
{
final void lock()
{
if(compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int i)
{
return nonfairTryAcquire(i);
}
private static final long serialVersionUID = 7316153563782823691L;
NonfairSync()
{
}
}
我们能够看出NonfairSync继承了Sync，下面我们下来看看Sync类是怎么写
static abstract class Sync extends AbstractQueuedSynchronizer
{
abstract void lock();
final boolean nonfairTryAcquire(int i)
{
Thread thread = Thread.currentThread();
int j = getState();
if(j == 0)
{
if(compareAndSetState(0, i))
{
setExclusiveOwnerThread(thread);
return true;
}
} else
if(thread == getExclusiveOwnerThread())
{
int k = j + i;
if(k < 0)
{
throw new Error("Maximum lock count exceeded");
} else
{
setState(k);
return true;
}
}
return false;
}
protected final boolean tryRelease(int i)
{
int j = getState() - i;
if(Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean flag = false;
if(j == 0)
{
flag = true;
setExclusiveOwnerThread(null);
}
setState(j);
return flag;
}
protected final boolean isHeldExclusively()
{
return getExclusiveOwnerThread() == Thread.currentThread();
}
final AbstractQueuedSynchronizer.ConditionObject newCondition()
{
return new AbstractQueuedSynchronizer.ConditionObject(this);
}
final Thread getOwner()
{
return getState() != 0 ? getExclusiveOwnerThread() : null;
}
final int getHoldCount()
{
return isHeldExclusively() ? getState() : 0;
}
final boolean isLocked()
{
return getState() != 0;
}
private void readObject(ObjectInputStream objectinputstream)
throws IOException, ClassNotFoundException
{
objectinputstream.defaultReadObject();
setState(0);
}
private static final long serialVersionUID = -5179523762034025860L;
Sync()
{
}
}
从源码中我们能够看出Sync是一个静态的抽象类，并且继承了AbstractQueuedSynchronizer(抽象队列同步器)类，其中AbstractQueuedSynchronizer就是我们所说的AQS了，关于AQS我们下次再聊。
插曲一下：
FairSync类和NonfairSync类都继承了Sync抽象类，其实这是一种模板方法设计模式，在Spring源码中AbstracBeanFactory是抽象类模板，AbstraAutowireCapableFactory和DefaultListableBeanFactory类都继承了AbstracBeanFactory类，因此也是一种模板方法模式。
3.NoFairSync类的分析
3.1 lock()方法分析
3.1.1 compareAndSetState()方法分析
我们先来看看NoFairSync中的第一个方法
final void lock()
{
if(compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
在lock方法中compareAndSetState(0,1)方法是父类中Sync的父类方法即AbstractQueuedSynchronizer实现方法该方法的代码如下
因此根据compareAndSwapInt代码功能我们能够知道：
表示如果当前state=0，那么设置state=1，并返回true，然后使用setExclusiveOwnerThread()方法把线程设为当前线程独占资源；否则返回false，执行acquire(1)方法
3.1.2 acquire(1)方法分析
接下来我们看看acquire(1)方法，该方法也是使用了父类AbstractQueuedSynchronizer的方法
public final void acquire(int i)
{
if(!tryAcquire(i) && acquireQueued(addWaiter(Node.EXCLUSIVE), i))
selfInterrupt();
}
从该方法中，我们能够看到它调用了tryAcquire(i)和acquireQueued(addWaiter(Node.EXCLUSIVE), i))方法
3.1.2.1 tryAcquire(i)分析
我们先来看看tryAcquire(i)方法的作用,该代码是在NoFairSync类中中的
//NoFairSync类中的
protected final boolean tryAcquire(int i)
{
return nonfairTryAcquire(i);//该方法是在父类Sync中实现的
}
--------------------------------------------------------------------------------------------------------------
//在Sync类中的
final boolean nonfairTryAcquire(int i)
{ //获取当前的线程
Thread thread = Thread.currentThread();
//得到当前线程的状态
int j = getState();
if(j == 0)
{
//如果该线程状态是为0，即处于空闲的状态，然后就重新CAS一次，如果返回为true，则把当前的threan设置当前拥有独占访问权限的线程
if(compareAndSetState(0, i))
{
setExclusiveOwnerThread(thread);
return true;
}
}
else if(thread == getExclusiveOwnerThread())//getExclusiveOwnerThread方法的作用是返回setExclusiveOwnerThread最后设置的线程，或null如果从未设置。 这种方法不会强加任何同步或volatile字段访问
{
int k = j + i;
//如果当前的线程已经获取了改锁，要求再次获取时，就会抛出Error
if(k < 0)
{
throw new Error("Maximum lock count exceeded");
} else
{
//否则就更新该线程的状态
setState(k);
return true;
}
}
return false;
}
3.1.2.1 addWaiter(Node.EXCLUSIVE), i)方法分析
addWaiter的代码如下，该方法是在AbstractQueuedSynchronizer.java文件中，下面我们分析一下该方法的作用：
其中 static final Node EXCLUSIVE = null;
通过源码我们能够知道Node.EXCLUSIVE的作用是是一个指向空指针的节点
private Node addWaiter(Node node)
{
//通过源码我们能够知道，该方法是为了把当前的线程初始化成一个节点，然后把节点返回
Node node1 = new Node(Thread.currentThread(), node);
Node node2 = tail;
//如果当前队列不是空队列，则把新节点加入到tail的后面，返回当前节点，否则进入enq进行处理。
if(node2 != null)
{
node1.prev = node2;
if(compareAndSetTail(node2, node1))
{
node2.next = node1;
return node1;
}
}
enq(node1);
return node1;
}
Node(x,y)初始化的代码，把当前节点放在队列尾部
Node(Thread thread1, Node node)
{
nextWaiter = node;
thread = thread1;
}
enq()方法作用分析，很明显该方法是为了把当前线程节点，放到队列的尾节点，该方法也是CAS的方式
private Node enq(Node node)
{
Node node1;
do
{
do
{
node1 = tail;
if(node1 != null)
break;
if(compareAndSetHead(new Node()))
tail = head;
} while(true);
node.prev = node1;
} while(!compareAndSetTail(node1, node));
node1.next = node;
return node1;
}
acquireQueued()方法分析
(1)如果当前节点是队列的头结点（如果第一个节点是虚拟节点，那么第二个节点实际上就是头结点了），就尝试在此获取锁tryAcquire(arg)。如果成功就将头结点设置为当前节点（不管第一个结点是否是虚拟节点），返回中断状态。否则进行(2)。
(2)检测当前节点是否应该park()-“挂起的意思”，如果应该park()就挂起当前线程并且返回当前线程中断状态。进行操作(1)。
final boolean acquireQueued(final Node node, int arg) {
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} catch (RuntimeException ex) {
cancelAcquire(node);
throw ex;
}
}
知识补充：线程有六个状态：新建（NEW）–0、运行（RUNNABLE）–1、阻塞（ BLOCKED）–2、等待（WAITING ）–3、限期等待（TIMED_WAITING）–4、完成(TERMINATED )–5,
不同的数字代表不同的状态即state的值。
static
{
NEW = new State("NEW", 0);
RUNNABLE = new State("RUNNABLE", 1);
BLOCKED = new State("BLOCKED", 2);
WAITING = new State("WAITING", 3);
TIMED_WAITING = new State("TIMED_WAITING", 4);
TERMINATED = new State("TERMINATED", 5);
$VALUES = (new State[] {
NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED
});
}
扫一扫
4781
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
