【JUC源码学习02】重入锁(ReentrantLock)学习

重入锁(ReentrantLock)学习

重入锁:也是排他锁:即在同一时刻只允许一个线程进行访问。

一、公平和非公平获取锁的区别

1、公平获取与非公平获取两者对比

公平锁:每次都是从同步队列中的第一个节点获取到锁

非公平性锁:每个线程可以连续多次获取锁

TODO: 缺图

非公平锁缺点:

  • 非公平锁,可能使线程“饥饿”,饥饿出现的情况。

  • 饥饿的原因:当一个线程请求锁时,只要获取了同步状态即成功获取锁。在这个前提下,刚释放锁的线程再次获取同步状态的几率非常大,使得其他线程只能在同步队列中等待。

2、为什么 ReentrankLock 默认是非公平锁实现?

如果把每次线程获取到锁定义为 1 次切换,公平性锁每次都要进行切换,而非公平性锁可以相比较而言减少线程切换。

TODO:缺图

通过实验对比结论:

在测试中,公平性锁与非公平性锁比较,总耗时是其 94.3 倍,总切换次数是其 103 倍。

可见:

  • 公平性锁保证了锁的获取按照 FIFO 原则,而代价是进行了大量的线程切换。

  • 非公平性锁虽然造成了线程“饥饿”,但极少的线程切换,保证了其更大的吞吐量。

二、非公平锁的获取和释放

以非公平锁的获取和释放为例。

1、tryAcquire(int acquires)

java.util.concurrent.locks.ReentrantLock.NonfairSync#tryAcquire

    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() {
            // 非公平锁的获取:只要 CAS 设置同步状态成功,则表示当前线程获取了锁
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

        // 非公平锁的获取
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

上面代码可以看到:非公平锁的获取,只要 CAS 设置同步状态成功,则表示当前线程获取了锁

1.1 nonfairTryAcquire(int 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;
        }

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

成功获取锁的线程再次获取锁,只是增加了同步状态值。

这也就要求 ReentrantLock 在释放同步状态时减少同步状态值。

2、 tryRelease(int releases)

		protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
               // 最终释放条件:同步状态是否为 0 
                free = true;
               // 将占有线程设置为 null
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

如果该锁被释放了 n 次,那么前(n-1)次 tryRelease(int releases)方法必须返回 flase,而只有同步状态完全释放了,才能返回 true。可以看到,该方法将同步状态是否为 0 作为最终释放的条件,当同步状态为0 时,将占有线程设置为 null,并返回 true,表示释放成功。

三、公平锁的获取与释放

公平和非公平,是针对锁而言的

如果一个锁是公平的,那么锁的获取顺序就应该符合请求的绝对时间顺序,也就是 FIFO。

下面有代码中有标记其区别:

1、tryAcquire(int acquires)方法

		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) {
                // 公平锁的获取与非公平锁区别:hasQueuedPredecessors()
                // 判断条件多了方法:加入了同步队列中当前节点是否有前驱节点的判断
                // 如果该方法返回 true,表示有线程比当前线程更早的请求获取锁,
                // 因此需要等待前驱线程获取锁并释放锁之后才能继续获取锁
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                   // cas 成功。
                    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;
        }
    }

2、hasQueuedPredecessors()

公平锁中加入的一个判断条件:加入了同步队列中当前节点是否有前驱节点的判断

  public final boolean hasQueuedPredecessors() {
        // The correctness of this depends on head being initialized
        // before tail and on head.next being accurate if the current
        // thread is first in queue.
        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>