Java并发编程-重入锁

章节目录

• 什么是重入锁
• 底层实现-如何实现重入
• 公平与非公平获取锁的区别与底层实现

1.什么是重入锁

1.1 重入锁的定义

重入锁ReentrantLock，支持重入的锁，表示一个线程对资源的重复加锁。

1.2 重入锁的特性

1.重进入
2.非/公平性获取锁

1.3 自定义同步器Mutex 的缺陷

当线程调用Mutex的lock()方法获取锁之后，再次调用lock()方法，该线程将会被
自己阻塞，原因是Mutex在实现tryAcquire(int acquires)方法时没有考虑占有锁
的线程再次获取锁的场景。

1.4 ReentrantLock & synchronized 关键字

1.synchronized 关键字支持隐式的重进入
2.ReentrantLock 在调用lock() 方法时，已经获取到锁的线程，能够再次调用
lock()方法获取到锁而不被阻塞，即可支持重入

1.4 公平性获取锁

公平性	含义
公平性获取锁	在绝对时间上，先对锁进行获取请求的请求一定先被满足，那么这个锁就是公平的
非公平性获取锁	无上述限制

事实上 公平锁机制往往没有非公平性机制获取锁的效率高，因为会牵扯到频繁的上下文切换，但公平锁可以减少饥饿发生的概率，等待越久的请求越能得到优先满足。

2. 底层实现-如何实现重入

重进入是指任意线程在获取到锁之后能够再次获取该锁，而不被阻塞，改特性实现需要解决以下两个问题：

• 线程再次获取锁

  线程再次获取锁。锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。
  

• 锁的最终释放

  线程重复n次获取了锁，随后在第n次释放锁，锁的释放要求锁对于被获取递
  增的次数进行递减操作，当计数==0时表示锁已经成功释放。
  

2.1 可重入锁的源码
非公平性获取同步状态(锁)的 nonfairTryAcquire() 方法

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

该方法增加了再次获取同步状态的处理逻辑:通过判断当前线程是否为获取锁的线程来决定获取操作是否成功，如果是获取锁的线程的再次请求 则将同步状态值计数器进行递增并返回true，表示获取同步状态成功。

释放同步状态(锁)

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

如果该锁被获取了n次，那么前n-1此tryRelease(int release) 方法必须返回false，而只有同步状态完全释放了，才能返回true。

3.公平与非公平获取锁的区别与底层实现

3.1 公平性获取锁的底层实现
公平性获取锁即按照客观时间顺序，FIFO方式获取同步状态
具体源码如下所示

  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,则表示有线程比当前线程更早的加入到同步队列（更早的请求获取锁），因此需要等待前驱线程获取并释放锁之后才能继续获取锁。

非公平性获取锁的实现

• 公平性获取锁保证了锁的获取顺序按照FIFO原则，不会出现线程“饥饿”的现象，但代价是进行大量的线程切换。
• 非公平性锁虽然可能造成线程饥饿，但是有极少的线程切换，保证了其更大的吞吐量。