栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

lock的底层的实现

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

lock的底层的实现

lock的底层的实现

实际上Lock实现类继承了内部类的sync实例,而这个sync就是abstractQueuedSynchroizer(AQS)

FairSync 与 NonfairSync 的区别在于,是不是保证获取锁的公平性,因为默认是 NonfairSync(非公平性)
lock有公平锁和非公平锁,而synchroized只有非公平锁

AQS

是jdk提供的一个同步框架,内部维护这FIFO的双向队列,即CLH同步队列

AQS依赖它来完成同步状态的管理(voliate修饰的state,用于标志是否持有锁)。如果获取同步状态的state失败时,会将当前线程及等待信息等构建一个Node,将Node放在FIFO队列中,同时阻塞当前线程,当线程将同步状态state释放时,会把FIFO队列中的首节的唤醒,使其获取同步状态state。

AQS的功能在使用中可以分为两种:独占锁 和 共享锁

独占锁:每次只能有一个线程持有锁。eg:ReentrantLock就是独占锁
共享锁:允许多个线程同时获得锁,并发访问共享资源。eg:ReentrantReadWriteLock中的读锁、CountDownLatch

实际上是依靠node这个静态内部类来实现的

此处,node相当于一个包装类,一个双向链表的结构。

node的实际用处:如果当前线程执行时发现,已经有其他线程获取到了锁,AQS就会将当前线程包装成一个node节点,添加到同步队列中,同时使队列阻塞。

  1. SIGNAL:值为-1,后继节点的线程处于等待状态,如果当前节点的线程释放了同步状态或者被取消时,将会通知后继节点,使后继节点得以运行。
  2. CANCELLED:值为1,由于在同步队列中等待的线程等待超时、被中断时,需要从同步队列中取消等待,节点进入该状态将不会变化。
  3. CONDITION:值为-2,节点在等待队列中,节点线程等待在 Condition 上,当其他线程对 Condition 调用了 signal()方法后,该节点将会从等待队列中转移至同步队列中,加入到对同步状态的获取中来。
  4. PROPAGATE:值为-3,表示下一次共享式同步状态获取将会无条件的被传播下去。
  5. INITIAL:值为0,初始状态。
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}
获取锁 tryAcquire

尝试去获取锁,获取成功返回true,否则返回false。该方法由AQS的子类自己实现。采用了模板方法和设计模式。

addWriter
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);//一直for循环
        return node;
    }
enq , 一直for循环,知道添加成功为止
 private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }
acquireQueued 不断的去获取同步锁的过程
final boolean acquireQueued(final Node node, long arg) {
        //操作是否成功的标记
        boolean failed = true;
        try {
            // 线程中断标记
            boolean interrupted = false;
            // 不断的自旋
            for (;;) {
                // 获取当前节点的prev节点
                final Node p = node.predecessor();
                //如果当前节点为头节点,且 是否获取到同步状态
                if (p == head && tryAcquire(arg)) {
                    // 就设置该节点为头节点
                    setHead(node);
                    // 将prev 移除队列中
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                //自旋的过程中,需要判断当前的线程是否需要阻塞 && 阻塞当前线程并且检验线程中
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
shouldParkAfterFailedAcquire
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        //拿到prev节点的等待状态
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            
            return true;
        if (ws > 0) {
            
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }
parkAndCheckInterrupt
private final boolean parkAndCheckInterrupt() {
        //阻塞当前线程
        LockSupport.park(this);
        //返回当前线程的中断状态
        return Thread.interrupted();
    }
selfInterrupt
  static void selfInterrupt() {
        // 未获取到同步状态 && 线程中断状态为true,中断当前线程
        Thread.currentThread().interrupt();
    }
释放锁 release
  public final boolean release(long arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
tryRelease

尝试去释放同步状态,释放成功后返回true,否则返回false。该方法由继承AQS的子类自己去实现。采用了模板方法设计模式

 protected boolean tryRelease(long arg) {
        throw new UnsupportedOperationException();
    }
unparkSuccessor
private void unparkSuccessor(Node node) {
        
         //获取当前节点的等待状态
        int ws = node.waitStatus;
        // 如果当前节点的状态 < 0 , 那么将CAS设置成0
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        
         //获取后继节点
        Node s = node.next;
        // 如果后继节点为空 || 伙计节点的状态 > 0 (为取消状态)
        if (s == null || s.waitStatus > 0) {
            s = null;
            //从尾节点查找状态不为取消的可用节点
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            // 唤醒后继节点
            LockSupport.unpark(s.thread);
    }
共享模式下的同步状态 acquireShared
public final void acquireShared(long arg) {
        if (tryAcquireShared(arg) < 0)
            //如果获取失败后,自旋获取同步状态
            doAcquireShared(arg);
    }
tryAcquireShared
protected long tryAcquireShared(long arg) {
        throw new UnsupportedOperationException();
    }
doAcquireShared
    private void doAcquireShared(long arg) {
        //添加共享模式节点到队列中
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            boolean interrupted = false;
            //自旋获取其同步状态
            for (;;) {
                  //获取其前驱节点
                final Node p = node.predecessor();

                if (p == head) {
                    //尝试去获取共享同步状态
                    long r = tryAcquireShared(arg);
                    if (r >= 0) {
                        // 将当前节点设置为头节点,并且释放也是共享模式的后继节点
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        if (interrupted)
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
setHeadAndPropagate
    private void setHeadAndPropagate(Node node, long propagate) {
        Node h = head; // Record old head for check below
        setHead(node);
        //
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            if (s == null || s.isShared())
                //真正的释放共享同步状态,并唤醒下一个节点
                doReleaseShared();
        }
    }
doReleaseShared
    private void doReleaseShared() {
        //自旋释放共享同步状态
        for (;;) {
            Node h = head;
            // 如果头节点不为空 && 头节点不等于尾节点,说明存在有效的node节点
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                //如果头节点的状态为signal,说明存在需要唤醒的后继节点
                if (ws == Node.SIGNAL) {
                    //将头节点状态更新为0(初始值状态),因为此时头节点已经没有用了,
                    //continue是为了保证替换成功。
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                        //唤醒后继节点
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // loop if head changed
                break;
        }
    }
unparkSuccessor
    private void unparkSuccessor(Node node) {
        
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/964034.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号