美文网首页
初探JUC锁机制

初探JUC锁机制

作者: 雅俗共赏M | 来源:发表于2017-03-24 16:41 被阅读381次

    最近觉着自己对java的一些高级用法不太了解,所以抽点时间来学习一下JUC锁机制。

    本文要点:

    1. 共享锁和独占锁
    1. 独占锁中的公平锁和非公平锁
    2. 公平/非公平锁 获取机制
    3. 锁和synchronized的区别

    1. 共享锁和独占锁

    共享锁:顾名思义,是指一个锁能够被多个线程共享使用。
    在java中,有类ReentrantReadWriteLock.ReadLockCyclicBarrierCountDownLatchSemaphore
    独占锁:是指一次只能被一个线程占用
    在java中,有类ReentrantLockReentrantReadWriteLock.WriteLock
    在java中,AQS->AbstractQueuedSynchronizer,是管理锁的抽象类,是独占锁和共享锁的公共父类。

    2. 独占锁中的公平锁和非公平锁

    公平锁:锁能够采用"公平"的策略分配给线程
    非公平锁:锁首先采用"不公平"的策略来分配给线程,如果失败,则再采用"公平"的策略来分配锁。

    所以,公平锁/非公平锁代表的是一种分配锁的机制、策略

    3. 公平/非公平锁 获取机制

    这里以ReentrantLock类来简单地分析一下这两种获取锁策略的实现原理:
    首先,类ReentrantLock实现接口Lock,其内部有一个final类型的Sync抽象类。

    private final Sync sync;
    

    该类继承自AbstractQueuedSynchronizer抽象类

    abstract static class Sync extends AbstractQueuedSynchronizer
    

    个人理解,该类AbstractQueuedSynchronizer的就是一个基于FIFO队列而实现的同步器,或者说是独占锁机制的内部实现。

    然后还是在ReentrantLock类内部,有两个内部类:NonfairSyncFairSync

    static final class NonfairSync extends Sync
    
    static final class FairSync extends Sync
    

    从这两个内部静态类的名字中也可以猜到,他们的作用就代表着公平锁/非公平锁的实现机制。

    那么接下来就简单分析一下从获取到释放锁的整个过程。

    首先先看一下ReentrantLock的构造方法:

        public ReentrantLock() {
            sync = new NonfairSync();
        }
    

    ReentrantLock默认构造方法初始化一个非公平锁NonfairSync,采用非公平锁机制

        public ReentrantLock(boolean fair) {
            sync = fair ? new FairSync() : new NonfairSync();
        }
    

    当然也可以传入boolean来选择获取锁的机制。

    ReentrantLock类初始化完成之后,首先调用lock方法

     public void lock() {
            sync.lock();
        }
    
    

    这个时候会根据sync的具体类型来调用不同的lock方法。

    ** 假如为公平锁FairSync,那么内部实现为 **

            final void lock() {
                acquire(1);
            }
    

    接下来再看acquire()方法

        public final void acquire(int arg) {
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }
    

    该acquire方法是在基类AbstractQueuedSynchronizer实现的。在该方法中,再调用一个tryAcquire来尝试获取锁:

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

    调用方法getState()获取当前锁的占用情况,如果c=0则说明当前锁没有线程占用,那么调用方法hasQueuedPredecessors来判断在AbstractQueuedSynchronizer中维护的FIFO队列是否还有线程,具体实现如下:

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

    如果在该队列中还有Node结点(即还有等待的线程),那么就返回true,否则返回false。

    1. 如果返回true,那么调用的方法 tryAcquire也就返回false,表示此次获取锁失败。接下来就执行方法addWaiter
        private Node addWaiter(Node mode) {
            Node node = new Node(Thread.currentThread(), mode);
            // Try the fast path of enq; backup to full enq on failure
            Node pred = tail;
            if (pred != null) {
                node.prev = pred;
                if (compareAndSetTail(pred, node)) {
                    pred.next = node;
                    return node;
                }
            }
            enq(node);
            return node;
        }
    

    该方法就是在FIFO队列的尾部新增一个Node结点,进而进行长路漫漫地排队等待。其实该结点就代表了这个线程。其中用到了CAS原子函数compareAndSetTail来将新增的Node设置为tail

    执行完addWaiter方法之后,紧接着就执行方法acquireQueued

        final boolean acquireQueued(final Node node, int arg) {
            boolean failed = true;
            try {
                boolean interrupted = false;
                for (;;) {
                    final Node p = node.predecessor();
                    if (p == head && tryAcquire(arg)) {
                        setHead(node);
                        p.next = null; // help GC
                        failed = false;
                        return interrupted;
                    }
                    if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                        interrupted = true;
                }
            } finally {
                if (failed)
                    cancelAcquire(node);
            }
        }
    

    该方法就是再一次去获取锁,只不过这一次是尝试给当前Node的上一个Node获取到锁,如果获取成功,则将当前Node设置为Head,否则继续阻塞等待。

    至此回想一下,对于公平锁来说,整个获取过程大致为:

    1. 外部程序调用公平锁的acquire(1)方法来获取锁
    2. 首先第一次调用tryAcquire来尝试获取锁,其内部实现原理是通过查看FIFO队列是否还有线程等待来判断能够获取到锁
    3. 如果第一次尝试失败,则调用addWaiter方法来将当前线程作为一个Node加入都FIFO队列的尾端。
    4. 加入到尾端之后,再一次调用acquireQueued方法来查看尾端的上一个Node结点是否是首部并且能否获取到锁,如果可以,则该尾部节点升为头部节点,反之阻塞等待。

    ** 假如为非公平锁NonFairSync,那么内部实现为 **

            final void lock() {
                if (compareAndSetState(0, 1))
                    setExclusiveOwnerThread(Thread.currentThread());
                else
                    acquire(1);
            }
    

    与上边说的公平锁一对比就很容易发现,这里多了一个CAS函数compareAndSetState,它是一个原子操作,作用是比较并设置当前锁的状态。若锁的状态值为0,则设置锁的状态值为1。如果操作成功,则调用setExclusiveOwnerThread方法来让自己获取到锁。其实这两步操作就体现了非公平锁的获取机制

    如果没能提前自己抢占到锁,那么就调用acquire(1)方法来获取了。接下来调用非公平锁的tryAcquire方法来尝试获取

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

    首先还是查看当前锁的state多少,如果为0,则再次调用CAS原子操作来抢占获取锁。如果该锁的state不为0, 则判断当前锁是不是自己持有的,如果是,则再次获取,并将state加1,否则返回false

    接下来的过程就和公平锁的一样了,如果没有获取到锁,则加入到FIFO队列,然后判断上一个结点等等操作。

    4. 独占锁锁和synchronized的区别

    synchronized:在很多线程同时竞争一个资源的时候,即在资源竞争激烈的情况下,性能会很低。如果线程较少,则性能还可以。
    独占锁:无论资源竞争是否激烈,性能都趋于平稳。其中的tryLock方法为非阻塞方法。

    以上就是我对于JUC独占锁的一些学习和总结,但是需要承认的是,里面还有许多细节之处没有讲清楚,其实也是我没有理解。好吧,先掌握住大体的框架,然后最弄懂细节之处。记住,不要让一些繁琐的细节影响了你对整体的把握!

    相关文章

      网友评论

          本文标题:初探JUC锁机制

          本文链接:https://www.haomeiwen.com/subject/rslznttx.html