深入学习java并发编程：ReentrantLock

1、相关类图

  

2、ReentrantLock实现分析说明

         ReentrantLock重入锁能支持一个线程对资源重复的加锁，而不会把自己锁死。此外，还支持获取锁是的公平和非公平性选择。ReentrantLock

虽然没有像synchronized关键字一样支持隐式的重进入，但是调用lock（）方，在已经获取到锁的情况下，能够再次调用lock()方法获取锁，而不被阻塞。

     1）实现可重入

      实现可重入需要解决两个问题：

        1 线程再次获取锁：锁需要识别获取所得线程是否是当前占据锁的线程，如果是，则再次获取到锁

        2锁的最终释放：线程重复n次获取锁，随后在第n次释放锁时，其他线程能够获取到锁。因此，锁的释放要求锁对于每次获取都进行计数自增，而在是释放时，计数自减，当计数减为0时，释 放锁。 在AQS里面有一个state字段，通过这个状态记录字段，记录锁获取的次数，它是一个volatile类型的整型值，因此对它的修改可以保证其他线程可以看到。

        ReentrantLock通过组合自定义同步器AQS实现锁的获取与释放，可以看到，针对公平锁与非公平锁，分别实现了FairSync和NonfairSync。

   构造器：

    public ReentrantLock() {   //默认是非公平锁

        sync = new NonfairSync();

    }

     public ReentrantLock(boolean fair) {

        sync = fair ? new FairSync() : new NonfairSync();

    }

获取以及释放同步状态：   

           内部自定义AQS如下：    

  abstract static class Sync extends AbstractQueuedSynchronizer {

        private static final long serialVersionUID = -5179523762034025860L;

        /**

         * Performs {@link Lock#lock}. The main reason for subclassing

         * is to allow fast path for nonfair version.

         */

        abstract void lock();

        /**

         * Performs non-fair tryLock.  tryAcquire is

         * implemented in subclasses, but both need nonfair

         * try for trylock method.

         */

        final boolean nonfairTryAcquire(int acquires) {

            final Thread current = Thread.currentThread();

            int c = getState();

            if (c == 0) {

                if (compareAndSetState(0, acquires)) {

                    setExclusiveOwnerThread(current);

                    return true;

                }

            }

            else if (current == getExclusiveOwnerThread()) {

                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;

            if (Thread.currentThread() != getExclusiveOwnerThread())

                throw new IllegalMonitorStateException();

            boolean free = false;

            if (c == 0) {

                free = true;

                setExclusiveOwnerThread(null);

            }

            setState(c);

            return free;

        }

        protected final boolean isHeldExclusively() {

            // While we must in general read state before owner,

            // we don't need to do so to check if current thread is owner

            return getExclusiveOwnerThread() == Thread.currentThread();

        }

     }

           可以看到，在 nonfairTryAcquire（int acquires）方法中添加了再次获取同步状态的处理逻辑：通过判断当前线程是否为获取锁的线程来决定获取操作是否成功，如果是获取锁的线程再次请求，则将同步状态值state进行增加并返回true，表示获取成功。

          tryRelease(int releases)  释放时，通过判断是否是当前线程，如果是，则减少同步状态值，当减为0是，就表示是最终释放，将占用线程设置为null，并设置free为true，返回。       

        NonfairSync 继承Sync ：

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);

        }

    }

   ）

2）公平获取锁状态

       公平与否，是针对获取同步状态而言的，如果锁是公平的，那么锁的获取就应该按照请求的时间顺序，也就是FIFO。

  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（）方法，及加入同步队列中当前节点是否有前驱节点的判断，如果该方法返回true，则表示有线程比当前线程更早的请求获取锁，因此需要等待前驱线程获取并释放锁之后才能继续获取锁。

3、ReentrantLock锁接口方法实现

   1）lock(): void 

  //方法中直接调用自定义同步器sync的lock()

    public void lock() {

        sync.lock();

    }

  2) lockInterruptibly(): void 

//调用自定义同步器sync的acquireInterruptibly模板方法

   public void lockInterruptibly() throws InterruptedException {

        sync.acquireInterruptibly(1);

    }

 3）unlock(): void

//调用自定义同步器sync的release模板方法

  public void unlock() {

        sync.release(1);

    }