ReentrantLock介绍

java.util.concurrent.locks.ReentrantLock

 

介绍：

    reentrant 是一个排它锁，和Synchronized有相同的作用，除此之外，还提了其他功能。

 

    ReentrantLock 通过调用lock方法，使线程获取锁，多线程同时获取锁时，只有一个线程可以得到此锁，其他的线程将处于阻塞状态。如果某个线程已经获得锁，再次请求获取锁时不会被阻塞，而是锁的计数器加一，可以通过isHeldByCurrentThread或者getHoldCount两个方法得到线程是否已经持有锁。

    

    ReentrantLock 提供了公平锁和非公平锁两种机制。公平锁可以保证等待时间最长的那个线程首先被唤醒，非公平锁则随机不能保证最长时间等待的线程最先获取锁。

     

    非公平锁的大致流程如下：

         1、当前锁未被持有时，如果此时有线程调用lock需要获取锁，则立马将锁给此线程（如果AQS中的FIFO队列中有线程在等待时，多个线程可能需要去同时抢锁了）。

         2、如果已经被持有了则调用acquire走AQS的流程，但是tryAcquire中实现的算法还是一个非公平锁。

         3、nonfairTryAcquire方法的第一步是做double check，具体的就是步骤1。

     4、如果锁确实被持有了，但是此时持有锁的线程是自己本人，所以就会累加锁的计数器。

     5、如果持有锁的线程不是本人，则进入AQS的等待队列中等待去了。

     从上面的流程可以看出，非公平锁的业务流程，谁先抢先一步想获取锁，则锁就分配给谁。

    

final static 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);
        }
    }

 

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

 

公平锁大致流程如下：

    1、线程想要获取锁，掉用lock从而执行AQS的流程。

    2、AQS首先会调用tryAcquire，这个方法内部有公平锁的所有业务流程。

    3、如果是获取锁的线程是AQS队列的第一个非Head节点节点，则得到锁，其他进入AQS的等待队列。

    AQS释放线程的顺序是从非head的第一个节点开始的，所以公平锁可以保证先获取锁的线程最先获得锁。·   

 

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 (isFirst(current) &&
                    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;
        }

 

  ReentrantLock使用lock时最好用try catch，在finally时将锁释放掉。

class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...
 
   public void m() {
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
 }