1.什么是锁?
锁是用来控制多个线程访问共享资源的方式,一般来说,锁是用来防止多个线程同时获取共享资源。在java 1.5 之前,使用synchronized 关键字来实现锁的功能,1.5之后提供了lock 接口,虽然lock接口失去了synchronized 隐式获取和释放锁的便捷,但是
却提供了获取和释放锁的可操作性,可中断的获取锁以及超时获取锁等 synchronized 等不具备的同步特性
2.使用示例
Lock lock = new ReentrantLock();
lock.lock();
try{
.......
}finally{
lock.unlock();
}
注意:1.synchronized同步块执行完成或者遇到异常是锁会自动释放 而 lock必须调用unlock 方法释放锁,因此在finally块中释放锁。
3.Lock 接口
public interface Lock {
//获取锁,如果锁不可用,当前线程被禁用以进行线程调度,在获取到锁之前,线程处于休眠状态
void lock();
//获取锁的过程能够响应线程中断,线程是可以被自己中断的 interupt 方法
void lockInterruptibly() throws InterruptedException;
//获取锁时锁是可用的立即返回true 否则立即返回false
boolean tryLock();
//如果线程在等待的时间内是空闲的并且未被中断则获取锁
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
//释放锁
void unlock();
获取与lock绑定的等待通知组件,当前线程必须持有锁才能进行等待,在开始等待之前会释放锁,在等待返回之前或重新获取锁
Condition newCondition();
}
ReentrantLock 继承了lock
public class ReentrantLock implements Lock, java.io.Serializable {
//获取锁,如果锁不可用,当前线程被禁用以进行线程调度,在获取到锁之前,线程处于休眠状态
void lock(){
sync.lock();
}
//获取锁的过程能够响应线程中断,线程是可以被自己中断的 interupt 方法
void lockInterruptibly() throws InterruptedException{
sync.acquireInterruptibly(1);
}
//获取锁时锁是可用的立即返回true 否则立即返回false
boolean tryLock(){
return sync.nonfairTryAcquire(1);
}
//如果线程在等待的时间内是空闲的并且未被中断则获取锁
boolean tryLock(long time, TimeUnit unit) throws InterruptedException{
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
//释放锁
void unlock(){
sync.release(1);
}
获取与lock绑定的等待通知组件,当前线程必须持有锁才能进行等待,在开始等待之前会释放锁,在等待返回之前或重新获取锁
Condition newCondition(){
return sync.newCondition();
}
}
可以看出ReentrantLock 实际是面向使用者的一个封装类,lock真正的实现是由sync 来实现的,通过源码发现这些并不是sync自己实现的而是它的父类 AbstractQueuedSynchronizer(队列同步器AQS)实现的.
AQS 数据结构
struct Node{
struct Node * pre;//前驱节点
struct Node * pNext;//后继节点
int waitStatus;
Thread * thread;//线程
struct Node * nextWaiter;// 模式 Node.EXCLUSIVE 独占, Node.SHARED 共享
}
队列
struct stack{
struct Node * pHead;
struct Node * pTail;
int state //当前同步状态
}
//双链表实现的队列
//1.初始化和2.入队 同时实现的
private Node enq(final Node node) {
//自旋
for (;;) {
Node t = tail;
//尾节点为空则创建一个节点设置为头节,并将尾节点指向头节点
//头节点、尾节点只是为了方便操作
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
//1.将插入的节点的前驱节点指向尾节点 2.将插入的节点设置为新的尾节点3.将之前的尾节点后继节点指向 插入的节点
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
//3.出队
1.直接从lock.lock() 入手
/**
* Sync object for non-fair locks
*/
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
//如果state 的值是0,初始化为0,直接将当前线程设置为独有访问权限的线程,将状态设置为1
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else//否则执行acquire
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
这里要引入 Unsafe.objectFieldOffset(Field),注释说是为了CAS 操作必须初始化一些参数,这应该是属性的内存编号偏移量
static {
try {
stateOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("state"));
headOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("head"));
tailOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
waitStatusOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField("waitStatus"));
nextOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField("next"));
} catch (Exception ex) { throw new Error(ex); }
}
2.acquire()
public final void acquire(int arg) {
//如果不能将当前线程设置为独占队列同步器访问权限的线程,即未获取到锁
// 执行addWaiter 并执行acquireQueued 方法
// acquireQueued 会一直阻塞直到产生的新节点的前驱节点是头节点并且状态为signal
//如果在阻塞过程中当前线程出现过中断 那么会重新产生一个中断
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
tryAcquire() 的实现调用
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
//获取当前同步状态
int c = getState();
if (c == 0) {
//如果当前状态是0 直接将状态更新为1 并将当前线程设置为同步器独占访问权限的线程
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
//如果当前线程独占访问权限的线程,并且状态不为0
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
//将状态设置为c + acquires(acquires = 1)
setState(nextc);
return true;
}
//否则返回false
return false;
}
//三种情况:1. state == 0,直接将当前线程设置为独占访问权限的线程,将状态改为acquires,从
//lock.lock() 那里走过来,acquires的值为1->state =1,返回true;
//2.state != 0 并且 当前线程就是独占访问权限的线程,如果state+1 <0 抛异常,否则将state设
//置为state+1,返回true
//3. 其他情况返回false
addWaiter(Node.EXCLUSIVE){
//将thread 封装成一个 node
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)) {
pred.next = node;
return node;
}
}
//初始化队列
enq(node);
return node;
}
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {//自旋
//当前节点的前驱节点
final Node p = node.predecessor();
//如果当前节点的前驱节点是头节点将尝试获取锁
//1.如果获取到锁 将当前节点设置为头节点
//断开之前头节点指向当前节点的指针,方便内存回收,返回false
//相当于出队
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
//2.其他任何情况,在node 的前驱成为头节点之前会无线循环检查线程是否中断
//如果已经中断第二次检查的时候会返回false
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
/** waitStatus value to indicate thread has cancelled */
static final int CANCELLED = 1;
/** waitStatus value to indicate successor's thread needs unparking */
static final int SIGNAL = -1;
/** waitStatus value to indicate thread is waiting on condition */
static final int CONDITION = -2;
/**
* waitStatus value to indicate the next acquireShared should
* unconditionally propagate
*/
static final int PROPAGATE = -3;
//如果线程应该阻塞返回true 否则false
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//pred 是node 的前驱节点
int ws = pred.waitStatus;
//如果前驱节点的状态已经是Node.SIGNAL 返回true
if (ws == Node.SIGNAL)
/*
* This node has already set status asking a release
* to signal it, so it can safely park.
*/
return true;
//
if (ws > 0) {//大于1 只有一种情况 cancelled
/*
* Predecessor was cancelled. Skip over predecessors and
* indicate retry.
*/
do {
//如果前驱节点被取消,将node 的前驱节点指向 pred 的前一个节点,但是pred 的后一个节点仍旧指向node,这样会导致最多2个节点的后继指向node
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
//将pred 的后继节点指向node
pred.next = node;
} else {
/*
* waitStatus must be 0 or PROPAGATE. Indicate that we
* need a signal, but don't park yet. Caller will need to
* retry to make sure it cannot acquire before parking.
*/
//将前驱节点的状态设置为SIGNAL 等待
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
/**
* Convenience method to park and then check if interrupted
*
* @return {@code true} if interrupted
*/
private final boolean parkAndCheckInterrupt() {
//禁用当前线程进行线程调度,并让当前线程处于休眠状态直到被唤醒(unpark,interupt)
LockSupport.park(this);
return Thread.interrupted();//如果当前线程是中断状态调用之后会清除状态,第二次返回false
}
//线程的中断只是将中断标志位设为true 当调用类似wait sleep 方法的时候会抛出异常并重置
//中断为false 唤醒线程,
//当node 的前驱成为头节点的时候,中断当前线程
static void selfInterrupt() {
Thread.currentThread().interrupt();
}
//独占模式的释放-> 释放头节点,直到队列同步器free 才算完全释放
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;
//如果state == 0 将队列同步器设置为空闲状态,将独占访问权限的线程置为空
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
//将状态设置为 state - 1
setState(c);
return free;
}
总结:每次调用lock.lock 的时候都会将state +1,释放的时候减一
//node 为头节点
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
int ws = node.waitStatus;
//不为cancelled 将waitStatus 设置为0 初始化状态
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
//头节点的后继节点
Node s = node.next;
//找到没有cancel 的后继节点
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
//唤醒该线程
if (s != null)
LockSupport.unpark(s.thread);
}
总结:
独占式锁按照队列的排列顺序获取锁
1.调用lock.lock() 的时候,先检查队列是否有初始化,没初始化先初始化队列的头节点,然后将当前线程封装成一个node(节点)插入在队列末尾,如果已经初始化,并且当前线程就是持有锁的线程,将state 设置成state+1。其他情况会尝试获取锁(state == 0 或者当前线程是持有锁的线程才会获取到锁)将当前线程封装成node(节点) 插入队列末尾,并且让当前线程休眠,将node 的状态waitstatus设置成singal。如果获取到锁会将头节点出队,并将当前节点设置为头节点。
2.当前持有锁的节点(头节点)的线程不会休眠,当你手动unlock 的时候,会释放锁,此时会unpark 唤醒下个节点的线程
总体来说:在获取同步状态时,AQS维护一个同步队列,获取同步状态失败的线程会加入到队列中进行自旋;移除队列(或停止自旋)的条件是前驱节点是头结点并且成功获得了同步状态。在释放同步状态时,同步器会调用unparkSuccessor()方法唤醒后继节点。
可中断获取锁lock.lockInterruptibly()
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
public final void acquireInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (!tryAcquire(arg))//没有获取到锁
doAcquireInterruptibly(arg);
}
private void doAcquireInterruptibly(int arg)
throws InterruptedException {
//将当前线程封装成node 加入到队列末尾
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
//自旋
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
//出队
p.next = null; // help GC
failed = false;
return;
}
//将p 的waitstatus设置为singal 让当前线程休眠
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
//当线程中断的时候抛出异常
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
超时等待式获取锁(tryAcquireNanos()方法)
通过调用lock.tryLock(timeout,TimeUnit)方式达到超时等待获取锁的效果,该方法会在三种情况下才会返回:
- 在超时时间内,当前线程成功获取了锁;
- 当前线程在超时时间内被中断;
- 超时时间结束,仍未获得锁返回false。
public final boolean tryAcquireNanos(int arg, long nanosTimeout) throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); return tryAcquire(arg) || doAcquireNanos(arg, nanosTimeout); } private boolean doAcquireNanos(int arg, long nanosTimeout) throws InterruptedException { if (nanosTimeout <= 0L) return false; //计算超时时间 final long deadline = System.nanoTime() + nanosTimeout; //将当前线程封装成node 入队 final Node node = addWaiter(Node.EXCLUSIVE); boolean failed = true; try { for (;;) { final Node p = node.predecessor(); if (p == head && tryAcquire(arg)) { //获取到锁就让头节点出队,把自己设成头节点 setHead(node); p.next = null; // help GC failed = false; return true; } //计算超时时间间隔 nanosTimeout = deadline - System.nanoTime(); if (nanosTimeout <= 0L)//表示已经超时 return false; if (shouldParkAfterFailedAcquire(p, node) && nanosTimeout > spinForTimeoutThreshold) //这段时间间隔之内当前线程不可调度,休眠 LockSupport.parkNanos(this, nanosTimeout); if (Thread.interrupted()) throw new InterruptedException(); } } finally { if (failed) cancelAcquire(node); } }
疑问1.LockSupport.park 到底是干什么的?文档上说以下三种情况会返回,否则会调用pthread.wait 进入等待状态
1.Some other thread invokes unpark with the current thread as the target;//调用了unparkSome
2.other thread interrupts the current thread; or// 调用了线程的interrupt
3.The call spuriously (that is, for no reason) returns.//莫名其妙的返回
所以那个自旋在线程进入wait 状态之后并没有继续执行,直到unpark 或者interrupt,当线程在wait状态被中断的时候 线程会被唤醒进入自旋并抛出异常,所以如果线程中断都是立即抛出异常的。
疑问2.这些没获取到同步状态的节点是怎么出队的?
那些返回false 将 cancelAcquire 出队
private void cancelAcquire(Node node) {
// Ignore if node doesn't exist
if (node == null)
return;
node.thread = null;
// Skip cancelled predecessors
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
// predNext is the apparent node to unsplice. CASes below will
// fail if not, in which case, we lost race vs another cancel
// or signal, so no further action is necessary.
Node predNext = pred.next;
// Can use unconditional write instead of CAS here.
// After this atomic step, other Nodes can skip past us.
// Before, we are free of interference from other threads.
node.waitStatus = Node.CANCELLED;
// If we are the tail, remove ourselves.
if (node == tail && compareAndSetTail(node, pred)) {
pred.compareAndSetNext(predNext, null);
} else {
// If successor needs signal, try to set pred's next-link
// so it will get one. Otherwise wake it up to propagate.
int ws;
if (pred != head &&
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && pred.compareAndSetWaitStatus(ws, Node.SIGNAL))) &&
pred.thread != null) {
Node next = node.next;
if (next != null && next.waitStatus <= 0)
pred.compareAndSetNext(predNext, next);
} else {
unparkSuccessor(node);
}
node.next = node; // help GC
}
}
共享锁
public final void acquireShared(int arg) {
//tryAcquireShared 没找到有实现这个方法的类
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
private void doAcquireShared(int arg) {
//加入队列
final Node node = addWaiter(Node.SHARED);
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
//获取到锁将头节点出队,让当前节点成为头节点
setHeadAndPropagate(node, r);
p.next = null; // help GC
//如果线程中断过再次调用interrupt
if (interrupted)
selfInterrupt();
return;
}
}
//将头节点的waitstatus 设置为signal 让当前线程进入wait
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} catch (Throwable t) {
cancelAcquire(node);
throw t;
}
}
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
private void doReleaseShared() {
/*
* Ensure that a release propagates, even if there are other
* in-progress acquires/releases. This proceeds in the usual
* way of trying to unparkSuccessor of head if it needs
* signal. But if it does not, status is set to PROPAGATE to
* ensure that upon release, propagation continues.
* Additionally, we must loop in case a new node is added
* while we are doing this. Also, unlike other uses of
* unparkSuccessor, we need to know if CAS to reset status
* fails, if so rechecking.
*/
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!h.compareAndSetWaitStatus(Node.SIGNAL, 0))
continue; // loop to recheck cases
unparkSuccessor(h);
}
else if (ws == 0 &&
!h.compareAndSetWaitStatus(0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}
//唤醒下个节点的线程
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
int ws = node.waitStatus;
if (ws < 0)
node.compareAndSetWaitStatus(ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node p = tail; p != node && p != null; p = p.prev)
if (p.waitStatus <= 0)
s = p;
}
if (s != null)
LockSupport.unpark(s.thread);
}
没找到共享锁的实现,但方式差不多,获取到锁将当前节点设置为头节点,前任头节点出队
总结:将java源码以数据结构的方式打开,队列同步器 不过是一个队列,指定了入队出队的方式,头节点能获取到锁,其他节点无法获取到锁,其他节点关联的线程进入等待状态,直到头节点释放锁出队,新的头节点获取到锁并唤醒线程。无法获取到的锁的节点会cancelAquire 出队