java并发-----浅析ReentrantLock加锁,解锁过程,公平锁非公平锁,AQS入门,CLH同步队列

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qq_41376740/article/details/80669851

前言

为什么需要去了解AQS,AQS,AbstractQueuedSynchronizer,即队列同步器。它是构建锁或者其他同步组件的基础框架(如ReentrantLock、ReentrantReadWriteLock、Semaphore等),JUC并发包的作者(Doug Lea)期望它能够成为实现大部分同步需求的基础。它是JUC并发包中的核心基础组件

本文所有源码基于JDK9
目的:掌握大概的流程/框架
适用人群:初学者想了解些源码的
不适合:想深入了解的

ReentrantLock-非公平锁

我们在实际中一定会用到ReentrantLock的lock操作,那么它的实现究竟是怎样的?我们以重入锁作为切入点。

1、构建锁,获得锁对象

//锁的声明
private final Sync sync;
// 构造锁,默认非公平
public ReentrantLock() {
sync = new NonfairSync();
}

2、lock方法,调用sync这个锁对象

    public void lock() {
        sync.acquire(1);
    }
    // 来自AQS
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

关键性的四个方法:

1、tryAcquire:去尝试获取锁,获取成功则设置锁状态并返回true,否则返回false。该方法自定义同步组件自己实现,该方法必须要保证线程安全的获取同步状态。

2、addWaiter:如果tryAcquire返回FALSE(获取同步状态失败),则调用该方法将当前线程加入到CLH同步队列尾部。

3、acquireQueued:当前线程会根据公平性原则来进行阻塞等待(自旋),直到获取锁为止;并且返回当前线程在等待过程中有没有中断过。

4、selfInterrupt:产生一个中断。

tryAcquire

    /**
     * Sync object for non-fair locks
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

加锁,是通过NonfairSync的这个方法实现的,但是NofairSync并没有它的实际代码。真正实现的是它的父类Sync。

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

getState(),这个方法在AQS中,用户获取锁的状态值。

    /**
     * Returns the current value of synchronization state.
     * This operation has memory semantics of a {@code volatile} read.
     * @return current state value
     */
    protected final int getState() {
        return state;
    }

下面来解释一下state在独占锁的作用是什么,结合下nonfairTryAcquire(int acquires)。

  • 首先第一个if条件,state = 0 的时候代表着,当前锁没有被某个线程占用,然后通过CAS操作设置线程的状态为值1,并且把当前线程设置为独占锁的拥有者。
  • 第二个if,当state!=0的时候,代表这个锁已经被别的线程占着了,就判断,这个是不是这个锁的拥有者,如果是的话,锁state就+1,这就巧妙地设置了重入锁的。每次+1的机制

CLH同步队列

在介绍addWaiter前,先来看一下CLH同步队列,就看着大佬们在说CLH但是少有人说他是啥,我解释一下啊

The wait queue is a variant of a “CLH” (Craig, Landin, and Hagersten) lock queue. CLH locks are normally used for spinlocks

1、名称:CLH 由三个人名字组成 (Craig, Landin, and Hagersten)
2、基本数据结构:基于FIFO双端链表
3、用途:用于等待资源释放的队列。也就是等待锁释放的队列

注意:由于笔者是初学者,觉得CLH队列中的等待状态转换略微复杂,故意跳过。只看它们的方法,并没有特别深入

addWaiter

    /**
     * Creates and enqueues node for current thread and given mode.
     *
     * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
     * @return the new node
     */
    private Node addWaiter(Node mode) {
        Node node = new Node(mode);

        for (;;) {
            Node oldTail = tail;
            if (oldTail != null) {
                node.setPrevRelaxed(oldTail);
                if (compareAndSetTail(oldTail, node)) {
                    oldTail.next = node;
                    return node;
                }
            } else {
                initializeSyncQueue();
            }
        }
    }

与JDK8不同的地方是,addWaiter直接使用自旋(无限循环)去完成入队的操作,而不是调用enq,实现的内容和enq差不多。下面给出enq的代码

    /**
     * Inserts node into queue, initializing if necessary. See picture above.
     * @param node the node to insert
     * @return node's predecessor
     */
    private Node enq(Node node) {
        for (;;) {
            Node oldTail = tail;
            if (oldTail != null) {
                node.setPrevRelaxed(oldTail);
                if (compareAndSetTail(oldTail, node)) {
                    oldTail.next = node;
                    return oldTail;
                }
            } else {
                initializeSyncQueue();
            }
        }
    }

注意addWaiter的返回值,是新加入的节点下面有用

acquireQueued

    final boolean acquireQueued(final Node node, int arg) {
        try {
            // 中断标识
            boolean interrupted = false;
            // 自旋
            for (;;) {
                final Node p = node.predecessor();
                // 如果当前线程节点的前驱节点是头结点,并且尝试获得锁成功
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    return interrupted;
                }
                // 如果获取锁失败了,就进入挂起。
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } catch (Throwable t) {
            cancelAcquire(node);
            throw t;
        }
    }

关于挂起和唤醒,就先不看了,主要还是理解下流程。过多的细节会拖慢新手的学习之路,一定要记住这个!!

RenentrantLock-公平锁

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()这个方法。

    public final boolean hasQueuedPredecessors() {
        Node t = tail; 
        Node h = head;
        Node s;
        // 头节点不是尾节点
        // 第一个节点不为空
        // 当前节点是头节点
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

从源码我们可以验证,公平和非公平的标准是否是按照队列的顺序进行锁的获取的原理。

小结:
到这里,加锁基本上就是结束了,我们忽略了挂起和唤醒这种复杂的操作。加锁的操作中,阻塞队列是由AQS使用CLH进行维护的。ReentrantLock,的同步操作主要还是依赖于AQS。

释放锁

    public void unlock() {
        sync.release(1);
    }
public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        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;
}

调用Sync的tryRelease,减小state值,然后uppark进行唤醒下一个节点PS,笔者忽略了唤醒的操作。

总结

本文针对和我一样刚入门不久的新手,从整体上以重入锁的加锁和解锁,去了解了一些AQS的CLH队列的基本内容,未涉及深层次,顺便看了下公平和非公平的实现。算作是一种了解把,个人感觉太细节的东西,新手看了也没用。还是从宏观上把握把握,会用,然后了解点源码,方便以后再来学习。

展开阅读全文

没有更多推荐了,返回首页