Lock的独占锁和共享锁的比较分析

Lock锁底层依赖于AQS实现，AQS提供了多种锁的实现模式，其中独占锁和共享锁是主要的两种模式。AQS本身是一种模板方法设计模式，即AQS对外部提供了一些模板方法，而这些模板方法又会调用由子类实现的抽象方法。今天我们主要是比较AQS中共享锁和独占锁的底层实现方面的不同。public final void acquire(int arg){/对外提供的独占锁的模板方法/ public final void acquireShared(int arg){ //对外提供的共享锁的模板方式 if(!tryAcquire(arg) if(tryAcquireShared(arg)<0) &&acquireQueued(addWaiter(Node.EXCLUSIVE),arg)) doAcquireShared(arg); selfInterrupt()/中断当前调用线程/ }}先来分析acuqire(arg)方法，首先我们要理解java中的短路运算符&&，也就是说当tryAcquire(arg)方法返回false时，即获取锁失败时，才会执行acquireQueued(addWaiter(Node.EXCLUSIVE),arg),剖开语句acquireQueued(**),先执行addWaiter(Node.EXCLUSIVE),然后执行acquireQueued(),所以一句if基本上就调用了所有的后续处理，这种编码方式，在java源码实现中非常常见。相比之下，acquireShared(arg)方法更加符合我们平时的编码习惯。addWaiter方法的目的是将未成功获取到锁的线程中加入到同步队列中去，先看源码： private Node addWaiter(Node mode){ private Node enq(final Node node){ Node node=new Node(Thread.currentThread(),mode); for(;;){ Node pred=tail; Node t=tail; if(pred!=null){ if(t==null){ node.prev=pred; if(compareAndSetHead(new Node())) if(compareAndSetTail(pred,node)){/注意该方式是原子方式/ tail=head; pred.next=node; }else{ return node; node.prev=t; } if(compareAndSetTail(t,node)){ } t.next=node; enq(node); return t; return node; } } } } } 上述的addWaiter方法首先构造一个新的节点，并先尝试插入同步队列，如果成功后，直接返回，如果不成功，则调用enq方法进行循环插入。节点既然已经被加入到同步队列中去了，那么接下来就需要将线程阻塞，阻塞之前需要再次尝试获取锁，如果仍然失败则阻塞，具体的处理方法在acquireQueued(node,arg); final boolean acquireQueued(final Node node,int arg){ boolean failed=true; try{ boolean interrupted=false; for(;;){ final Node p=node.predecessor(); if(p==head&&tryAcquire(arg)){ setHead(node);//注意这一段代码并没有进行并发控制，因为这一句是由获取锁的线程设置，所以不需要进行同步控制 p.next=null; failed=false; return interrupted; } if(shouldParkAfterFailedAcquire(p,node)&&parkAndCheckInterrupt()) interrupted=true; } }finally{ if(failed) cancelAcquire(node); } }在上述代码中，关键的一点是shouParkAfterFailedAcquire方法和parkAndCheckInterrupt方法，接下来我们看下这两个函数的源码实现： private static boolean shouldParkAfterFailedAcquire(Node pred,Node node){ int ws=pred.waitStatus; if(ws==Node.SIGNAL) return true;// SIGNAL表示该节点的后继节点正在阻塞中，当该节点释放时，将唤醒后继节点。此时node可以安全地进行阻塞，因为可以保证会被唤醒 if(ws>0){//表示前置节点已经被取消 do{//循环找到一个未被取消的节点 node.prev=pred=pred.prev; }while(pred.waitStatus>0); pred.next=node; //执行到这一句时，acquireQueued方法会循环一次，再次尝试获取锁 }else{ compareAndSetWaitStatus(pred,ws,Node.SIGNAL); } return false; }规则1：如果前继的节点状态为SIGNAL，表明当前节点可以安全地进行阻塞，则返回成功，此时acquireQueued方法的第12行（parkAndCheckInterrupt）将导致线程阻塞规则2：如果前继节点状态为CANCELLED(ws>0)，说明前置节点已经被放弃，则回溯到一个非取消的前继节点，返回false，acquireQueued方法的无限循环将递归调用该方法，直至规则1返回true，导致线程阻塞规则3：如果前继节点状态为非SIGNAL、非CANCELLED，则设置前继的状态为SIGNAL，返回false后进入acquireQueued的无限循环，与规则2同下面我们再来分析一下，共享锁acquireShared()方法中的doAcquireShared(arg),调用该方法说明，共享锁已经用完了，当前线程需要进行等待重新获取： private void doAcquireShared(int arg){ final Node node=addWaiter(Node.SHARED);//构造一个新的节点，并将新的节点加入到同步队列中 boolean failed=true; 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; if(interrupted) selfInterrupt(); failed=false; return; } if(shouldParkAfterFailedAcquire(p,node)&&parkAndCheckInterrupt())//同独占锁的规则一样 interrupted=true; } } }finally{ if(failed) cancelAcquire(node); } }上面的代码中主要的一句关键代码是setHeadAndPropagate方法，主要能够调用setHeadAndPropagate方法，说明当前线程已经活到了锁，下面我们来看看这句代码的实现： private void setHeadAndPropagate(Node node,int propagate){ Node h=head; setHead(node);//因为有多个线程可能同时获取了共享锁，setHead方法可能会设置不成功，不过已经获取了锁，也不用关心是否设置成功 if(propagate>0||h==null||h.waitStatus<0){ Node s=node.next; if(s==null||s.isShared()) doReleaseShared(); } }独占锁某个节点被唤醒之后，它只需要将这个节点设置成head就完事了，而共享锁不一样，某个节点被设置为head之后，如果它的后继节点是SHARED状态的，那么将继续通过doReleaseShared方法尝试往后唤醒节点，实现了共享状态的向后传播。