重入锁----ReentrantLock

本节主要从下述四个方面介绍重入锁。

 1.什么是重入锁？

 2.为什么要引用重入锁？

 3.重入锁是怎么实现的？

 4.分析java并发包中ReentrantLock。

什么是重入锁

重入锁，支持重进入的锁，表示该锁能够支持一个线程对它重复加锁，即线程在获得锁之后再次获取该锁时不会被阻塞。

为什么要引用重入锁？

以子类重写父类方法为例：

Mutix是不支持重入的锁。（代码摘抄自《java并发编程的艺术》）

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.*;



public class Mutix implements Lock
{
    private static class Sync extends AbstractQueuedSynchronizer{
        //是否处于占用状态
        protected boolean isHeldExclusively(){
            return this.getState()==1;
        }
        protected boolean tryAcquire(int acquires){
            if(compareAndSetState(0,1)){
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
            
        }
        protected boolean tryRelease(int releases){
            if(getState()==0)throw new IllegalMonitorStateException();
            setExclusiveOwnerThread(null);
            setState(0);
            
            return true;
            
        }
        Condition newCondition(){
            return new ConditionObject();
        }
        
    }
    private final Sync sync=new Sync();

    @Override
    public void lock()
    {
        // TODO Auto-generated method stub
    sync.acquire(1);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException
    {
        // TODO Auto-generated method stub
sync.acquireInterruptibly(1);
    }

    @Override
    public Condition newCondition()
    {
        // TODO Auto-generated method stub
        return sync.newCondition();
    }

    @Override
    public boolean tryLock()
    {
        // TODO Auto-generated method stub
        return sync.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long arg0, TimeUnit arg1)
            throws InterruptedException
    {
        // TODO Auto-generated method stub
        return sync.tryAcquireNanos(1, arg1.toNanos(arg0));
    }

    @Override
    public void unlock()
    {
        // TODO Auto-generated method stub
sync.release(1);
    }
    public boolean hasQueuedThreads(){
        return sync.hasQueuedThreads();
    }

}

分别以支持重入和不支持重入进行测试；

测试代码如下：

import java.util.concurrent.locks.ReentrantLock;


public class TestLock
{
    static Mutix lock=new Mutix();
//    static ReentrantLock lock=new ReentrantLock();

    public static class Widget {  
        public  void doSomething() {  
            lock.lock();
            try{
            System.out.println("父类Widget,线程名称:" +Thread.currentThread().getName());
            }finally{
                lock.unlock();
            }
        }  
    }  
      
    public static class LoggingWidget extends Widget {  
        public  void doSomething() {  
            lock.lock();
            try{
                 System.out.println("子类LoggingWidget: calling doSomething,线程名称:" +Thread.currentThread().getName());
            super.doSomething();  
            }finally{
                lock.unlock();
            }
        }  
    }  
    
    

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        LoggingWidget test=new LoggingWidget();
        test.doSomething();
    }

}

当使用ReentrantLock可重入锁时，显示结果如下：

子类LoggingWidget: calling doSomething,线程名称:main
父类Widget,线程名称:main

当使用Mutix不可重入锁时，结果如下：

子类LoggingWidget: calling doSomething,线程名称:main

此时程序并没有结束，而是一直在等待父类的锁，通过jstack命令，查看到Main进程处于等待状态。按正常的处理逻辑，子类是允许调用父类的方法，故重入锁在实际应用中还是很重要的。

重入锁是怎么实现？

1）线程再次获取锁。需要判断当前获取锁的线程是否为当前占据锁的线程，如果是，则再次获取成功。

2）锁的最终释放。若线程重复了N次获得了锁，那需要释放N次才能真正释放该锁。线程再次获取锁时，计时器加1，当释放锁时，计数器减1。

分析java并发包中ReentrantLock。

1）自定义组合同步器实现锁的获取和释放，默认是以非公平形式获取锁。

        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();//当前线程
            int c = getState();//获取同步状态
            if (c == 0) {//如果同步状态为0，表示当前没有线程获取锁
                if (compareAndSetState(0, acquires)) {//通过CAS算法获取锁
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                //如果同步状态不为0，表示已经有线程获取了该锁，判断获取锁的线程是否为当前线程，如果时，同步状态加acquires，一般为加1
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);//设置同步状态
                return true;
            }
            return false;
        }

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;//计算当前同步状态减去releases
            if (Thread.currentThread() != getExclusiveOwnerThread())//如果当前线程不等于获取锁的线程
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {//如果C==0,表示同步状态完全释放，将占用线程设置为Null,并且返回true
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

在调用ReentrantLock的lock和unlock方法时，实际是调用同步器中的方法。

 public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }
 public void unlock() {
        sync.release(1);
    }

从代码中可以看到，最终调用的是sync中的方法，对于用户而言，sync是透明的。

2）公平和非公平获取锁。

 /**
     * 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() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
            //直接调用Sync的方法。
        }
    }

 static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }

        /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        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;
        }
    }

公平和非公平最大区别在于：公平锁需要判断当前节点的前一个节点是否为头节点(hasQueuedPredecessors() )，如果是，才允许通过CAS算法获取锁，如果不是，表示有线程比当前线程更早的获取锁，因此需要等待前驱线程获取锁并释放锁之后才能继续获取锁。非公平不需要进行判断。公平锁保证了线程处理之间的公平，通过FIFO，保证了公平性，而代价是进行大量的线程切换。非公平锁虽然有时会造成线程饥饿，但极少的线程切换，保证了更大的吞吐量。

ReentrantLock锁默认采用的是非公平锁。

 public ReentrantLock() {
        sync = new NonfairSync();//默认采用非公平锁
    }

总结：最近这几天在看《JAVA并发编程的艺术》，作者讲解的很详细，本来不想写博客，网上关于这些的文章已经非常多了，而且该书讲解的那么透彻，但后来想想，在写博客其实也是整理、梳理知识的过程，如果自己都没有弄明白，如何能够写出来。