ReentrantLock解析,lock与unlock方法分析

Posted 2020-07-07 占用我名字

介绍ReentrantLock之前，先介绍下背景知识，也就是要用到的知识点。这些知识点包括：比较并交换CAS(Compare And Swap )、ReentrantLock的类结构（其父类，内部类等）。

声明：

我主要是通过一种通俗的语言进行内容的总结，帮助大家更好的理解，记忆，更容易去理解书上的讲解。对于一些专业的陈述，大家还是需要去看书。

1、CAS 

举例说明。对于如下类

public class Blog {
	private int count;
	
	public int getCount(){
		return count;
	}
	public synchronized int increCount(){
		return ++count;
	}
}

这里有10个线程都要对变量count进行加1的操作。这种情况下我们会对其进行并发控制。也就是加synchronized关键字或者使用ReentrantLock对象的lock方法进行加锁，如increCount()方法。而CAS并不需要使用这些，就可以保证变量a最后结果的正确性。

其实CAS指的是sun.misc.Unsafe这个类中的一些方法的统称。例如，Unsafe这个类中有compareAndSwapInt、compareAndSwapLong等方法。

CAS的过程是：它包含了3个参数CAS(O,V,E,N)。O表示要更新的对象。V表示指明更新的对象中的哪个变量，E是进行比较的值，如果V==E，则将N赋值给V。

这里以JDK中的AtomicInteger类来进行分析。

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;


    private static final Unsafe unsafe = Unsafe.getUnsafe(); //这里是初始化一个Unsafe对象。因为CAS是这个类中的方法。
    private static final long valueOffset;

    static {
      try {
    	
    	  /*一个java对象可以看成是一段内存，各个字段都得按照一定的顺序放在这段内存里，
    	  同时考虑到对齐要求，可能这些字段不是连续放置的，用这个方法能准确地告诉你某个
    	  字段(也就是下面的value字段)相对于对象的起始内存地址的字节偏移量，因为是相对
    	  偏移量，所以它其实跟某个具体对象又没什么太大关系，跟class的定义和虚拟机的内
    	  存模型的实现细节更相关。通俗一点就是在CAS(O,V,E,N)中，O是你要更新那个对象，
    	  V就是我要通过这个偏移量找到这个对象中的value对象，来对他进行操作。*/
    	  
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value")); 
      } catch (Exception ex) { throw new Error(ex); }
    }
    //volatile,保证变量的可见性。
    private volatile int value;

    //有参构造
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

   
    public AtomicInteger() {
    }
    
    public final int get() {
        return value;
    }
    
    public final int getAndIncrement() {
    	//为什么会无限循环，后面的方法中会说明
        for (;;) {
            int current = get(); //得到当前的值
            int next = current + 1;
            if (compareAndSet(current, next))
                return current;
        }
    }

  
    public final boolean compareAndSet(int expect, int update) {
    /*this指的是该对象，valueOffset就是前面讲的偏移量，找到偏移量对应的值，也就是value变量
          对应的值，如果except等于这个value,则将value更改为update。可能这大家会有个问题是，如果我两个
          线程同时读，expect的值一样，都等于value，这样两个线程进行判断的时候value都等于except,都将update赋值给value
          ，结果会造成最后的结果不正确。其实这个方法是native方法，同时也是同步的，一个线程进行操作，另一个线程是需要
          等待的，虽然两个线程的expect的值一致，但是当第二个线程再调用这个方法时，value的值已经发生了变化。
        此时会返回false,所以在上述的getAndIncrement()方法中会使用for进行无线循环。 */
	return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
    
}

2、ReentrantLock的类结构

ReentrantLock实现了Lock接口，而Lock接口主要提供了以下方法：

   void lock();
   void lockInterruptibly() throws InterruptedException;
   boolean tryLock();
   boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
   void unlock();
   Condition newCondition();

ReentrantLock类有一个静态内部抽象类Sync，这个Sync继承AbstractQueuedSynchronizer类，AbstractQueuedSynchronizer类继承自AbstractOwnableSynchronizer。

而ReentrantLock类中还有两个静态内部类，分别为NonfairSync（非公平锁）和FairSync（公平锁）。在AbstractQueuedSynchronizer抽象类中有一个静态内部类Node，这个Node就是存放等待线程的节点。

3、分析lock()方法

ReentrantLock类有一个成员变量为private final Sync sync; ReentrantLock的lock()、unLock()等方法，调用的都是sync的一些方法。如下：

public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;
    /** Synchronizer providing all implementation mechanics */
    private final Sync sync;
   
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    
    public ReentrantLock(boolean fair) {
        sync = (fair)? new FairSync() : new NonfairSync(); //构造时指定为公平锁还是非公平锁
    }
    
    public void lock() {
        sync.lock();
    }
    
    public void unlock() {
        sync.release(1);
    }
}

公平锁与非公平锁的区别在于：如果有10个线程，第1个线程获取了锁，紧接着有8个线程已经处在了等待释放锁。如果是非公平锁的话，第10个线程可以尝试直接获取锁，有可能是第1个线程释放锁了以后第10个直接就获取了。而公平锁就是，第10个线程必须等待前面的线程都获取锁，并释放，才可以获取锁，先进先出的意思。

这里以非公平锁来进行分析。

当调用lock()方法是，也就是执行了sync.lock()方法，如下是代码：

       final void lock() {
            if (compareAndSetState(0, 1)) //首先尝试获取锁。该方法在下面有说明
                setExclusiveOwnerThread(Thread.currentThread());//如果获取锁，则将当前线程赋值给exclusiveOwnerThread变量。
             else
                acquire(1);//如果失败，则调用此方法。继续往下看这个方法。
        }

    //   stateOffset = unsafe.objectFieldOffset
    //(AbstractQueuedSynchronizer.class.getDeclaredField("state"));
    protected final boolean compareAndSetState(int expect, int update) {
        //这个stateOffset对应的是Sync的父类中的state字段，这个字段用来标识是否有线程已经获取锁
    	//如果有的话，state>0，否则state==0；所以如果expect==state==0，那么就获取锁，将
    	//state置为1
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

    public final void acquire(int arg) {
    	//先尝试获取锁，如果获取锁失败了，也就是！tryAcquire(arg)为true则执行
    	//后面的方法。注意&&,前面为true后面才执行。获取锁失败后，会将该线程加入等待队列
        if (!tryAcquire(arg) &&      
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);//我们是以非公平锁来讲解的。
        }

    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) { //状态为0，说明没有线程获取锁。尝试获取锁
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        //如果当前线程为exclusiveOwnerThread变量中存储的线程，说明当前线程已经
        //获取了锁，这里是当前线程再次要获得锁，所以state要继续+1。
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        //获取锁失败，返回false。
        return false;
    }

讲完了tryAcquire(arg)方法，紧接着讲 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)这两个方法。

    private Node addWaiter(Node mode) {
    	//当前线程节点，可以看看Node类中的一些变量和方法，比较简单。
        Node node = new Node(Thread.currentThread(), mode);
        
        Node pred = tail;
        //判断有没有尾节点（也就是前面是否有等待线程）。如果有尾节点，则将当前线程的节点插入到队列的尾部
        //也就是将当前线程变成尾节点。
        if (pred != null) {
            node.prev = pred;
            //CAS的操作。
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        //如果没有尾节点，说明前面还未有等待线程。调用下面的方法，创建等待队列
        enq(node);
        return node;
    }

    private Node enq(final Node node) {
    	//enq方法主要是创建头，尾节点，也就是等待队列，下面都会用的CAS同步操作，加上
    	//for循环，防止两个线程同时创建头尾节点。代码比较容易读懂
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                Node h = new Node(); // Dummy header
                h.next = node;
                node.prev = h;
                if (compareAndSetHead(h)) {
                    tail = node;
                    return h;
                }
            }
            else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

addWaiter方法分析完了，紧接着就是acquireQueued(addWaiter(Node.EXCLUSIVE), arg))中的acquireQueued方法。

    //这个方法是不断地获取锁，直到成功的获取锁
    final boolean acquireQueued(final Node node, int arg) {
        try {
            boolean interrupted = false;
            for (;;) {
            	//得到当前节点的上一个节点
                final Node p = node.predecessor();
                //p==head意思是如果上一个节点为头节点，才尝试获取锁，为什么呢？
                //因为公平锁也会调用这个方法，这里要保证公平，只有当前线程节点在队列的第一个
                //才可以获取锁。
                if (p == head && tryAcquire(arg)) {
                	//如果成果获得锁，则将当前节点变成头结点。因为获得锁，所以当前节点要移出等待
                	//队列，变成了头结点。
                    setHead(node);
                    p.next = null; // help GC
                    return interrupted;
                }
                //第一个方法是如果获取失败，是否要对当前线程进行阻塞(后面有分析)。防止线程一直进行for循环。
                //&&后面的方法是对当前线程进行阻塞并且判断是否中断。这里注意的是，如果一个线程在
                //等待锁期间这个线程被中断了，这里会将interrupted赋为true,但是并不return。这个
                //还一直进行for循环，知道这个线程获得了锁，所以lock()方法不能立即响应中断，必须等线程
                //获得了锁才可以响应中断。对应的可以立即响应中断的方法为lockInterruptibly()方法
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } catch (RuntimeException ex) {
            cancelAcquire(node);
            throw ex;
        }
    }

    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        //这个pre是当前节点（node）的上一个节点。waitStatus有4个状态，这个方法后有说明
    	int s = pred.waitStatus;
    	//小于0，也就是SIGNAL状态，或者是CONDITION状态
        if (s < 0)
            return true;
      //大于0，也就是CANCLE状态。
        if (s > 0) {
	    do {
		node.prev = pred = pred.prev;/
	    } while (pred.waitStatus > 0);
	    pred.next = node;
    }
        else
        	//这里为什么要将当前节点的父节点的waitStatus设置成-1呢，这是因为
        	//在unLock()方法中会根据当前节点的waitStatus来判断后续是否还有节点。
        	//如果当前的waitStatus==-1,说明有后续节点对其进行了设置。后续节点
        	//处在阻塞状态。后面会对unLock()方法进行分析。
            compareAndSetWaitStatus(pred, 0, Node.SIGNAL);
        return false;
    }

        static final int CANCELLED =  1;//这个状态说明该节点已经被取消。
        
        static final int SIGNAL    = -1;//这个状态说明该节点后续有阻塞的节点
        
        static final int CONDITION = -2;//这个状态跟Condition有关，也就是线程之间通过Condition方法进行通信。我会在接下的博客中写有关Condition的文章

   private final boolean parkAndCheckInterrupt() {
    	//阻塞当前线程
        LockSupport.park(this);
        return Thread.interrupted();
    }

4、unLock()方法

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

    public final boolean release(int arg) {
    	//tryRelease(arg)是将state标志位置为0，用来让其他线程获取锁。
        if (tryRelease(arg)) {
            Node h = head;
            //如果h.waitStatus不等于0，说明后面有线程再等待，前面shouldParkAfterFailedAcquire()
            //方法有说明。
            if (h != null && h.waitStatus != 0)
            	//这个方法后面有分析。主要是将头结点的waitStatus置为0，同时通知下一个节点。
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

 

    private void unparkSuccessor(Node node) {
    	
    	/**
    	 * 将头节点的waitStatus状态置为0
    	 */
        compareAndSetWaitStatus(node, Node.SIGNAL, 0);

        /**
         * 获取下一个节点，如果下一个节点被取消或者为空，则从尾部还是查找，找到第一个可用的线程
         * 。
         */
        Node s = node.next;
        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);
    }

5、Lock VS Sychronized（引用别人博文上的）

AbstractQueuedSynchronizer通过构造一个基于阻塞的CLH队列容纳所有的阻塞线程，而对该队列的操作均通过Lock-Free（CAS）操作，但对已经获得锁的线程而言，ReentrantLock实现了偏向锁的功能。

synchronized 的底层也是一个基于CAS操作的等待队列，但JVM实现的更精细，把等待队列分为ContentionList和EntryList，目的是为了降低线程的出列速度；当然也实现了偏向锁，从数据结构来说二者设计没有本质区别。但synchronized还实现了自旋锁，并针对不同的系统和硬件体系进行了优 化，而Lock则完全依靠系统阻塞挂起等待线程。

当然Lock比synchronized更适合在应用层扩展，可以继承 AbstractQueuedSynchronizer定义各种实现，比如实现读写锁（ReadWriteLock），公平或不公平锁；同时，Lock对 应的Condition也比wait/notify要方便的多、灵活的多。

6、总结

以上主要分析了从加锁到解锁的过程，公平锁跟这个类似，读懂这个，其他的方法比如lockInterruptibly()，也很容易明白，如果有不明白可以留言，或者有什么建议，我写的不对的地方，都可以告诉我，我们共同成长。