<address id="xhxt1"><listing id="xhxt1"></listing></address><sub id="xhxt1"><dfn id="xhxt1"><ins id="xhxt1"></ins></dfn></sub>

    <thead id="xhxt1"><dfn id="xhxt1"><ins id="xhxt1"></ins></dfn></thead>

    Java锁的种类以及辨析(二):自旋锁的其他种类

    下载

    作者:山鸡

    锁作为并发共享数据,保证一致性的工具,在JAVA平台有多种实现(如 synchronized 和 ReentrantLock等等 ) 。这些已经写好提供的锁为我们开发提供了便利,但是锁的具体性质以及类型却很少被提及。本系列文章将分析JAVA下常见的锁名称以及特性,为大家答疑解惑。

    2.自旋锁的其他种类

    上篇我们讲到了自旋锁,在自旋锁中 另有三种常见的锁形式:TicketLock ,CLHlock 和MCSlock

    Ticket锁主要解决的是访问顺序的问题,主要的问题是在多核cpu上

    package com.alipay.titan.dcc.dal.entity;
    
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class TicketLock {
        private AtomicInteger                     serviceNum = new AtomicInteger();
        private AtomicInteger                     ticketNum  = new AtomicInteger();
        private static final ThreadLocal<Integer> LOCAL      = new ThreadLocal<Integer>();
    
        public void lock() {
            int myticket = ticketNum.getAndIncrement();
            LOCAL.set(myticket);
            while (myticket != serviceNum.get()) {
            }
    
        }
    
        public void unlock() {
            int myticket = LOCAL.get();
            serviceNum.compareAndSet(myticket, myticket + 1);
        }
    }
    

    每次都要查询一个serviceNum 服务号,影响性能(必须要到主内存读取,并阻止其他cpu修改)。

    CLHLock 和MCSLock 则是两种类型相似的公平锁,采用链表的形式进行排序,

    
    import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
    
    public class CLHLock {
        public static class CLHNode {
            private volatile boolean isLocked = true;
        }
    
        @SuppressWarnings("unused")
        private volatile CLHNode                                           tail;
        private static final ThreadLocal<CLHNode>                          LOCAL   = new ThreadLocal<CLHNode>();
        private static final AtomicReferenceFieldUpdater<CLHLock, CLHNode> UPDATER = AtomicReferenceFieldUpdater.newUpdater(CLHLock.class,
                                                                                       CLHNode.class, "tail");
    
        public void lock() {
            CLHNode node = new CLHNode();
            LOCAL.set(node);
            CLHNode preNode = UPDATER.getAndSet(this, node);
            if (preNode != null) {
                while (preNode.isLocked) {
                }
                preNode = null;
                LOCAL.set(node);
            }
        }
    
        public void unlock() {
            CLHNode node = LOCAL.get();
            if (!UPDATER.compareAndSet(this, node, null)) {
                node.isLocked = false;
            }
            node = null;
        }
    }
    

     

    CLHlock是不停的查询前驱变量, 导致不适合在NUMA 架构下使用(在这种结构下,每个线程分布在不同的物理内存区域)

    MCSLock则是对本地变量的节点进行循环。不存在CLHlock 的问题。

    import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
    
    public class MCSLock {
        public static class MCSNode {
            volatile MCSNode next;
            volatile boolean isLocked = true;
        }
    
        private static final ThreadLocal<MCSNode>                          NODE    = new ThreadLocal<MCSNode>();
        @SuppressWarnings("unused")
        private volatile MCSNode                                           queue;
        private static final AtomicReferenceFieldUpdater<MCSLock, MCSNode> UPDATER = AtomicReferenceFieldUpdater.newUpdater(MCSLock.class,
                                                                                       MCSNode.class, "queue");
    
        public void lock() {
            MCSNode currentNode = new MCSNode();
            NODE.set(currentNode);
            MCSNode preNode = UPDATER.getAndSet(this, currentNode);
            if (preNode != null) {
                preNode.next = currentNode;
                while (currentNode.isLocked) {
    
                }
            }
        }
    
        public void unlock() {
            MCSNode currentNode = NODE.get();
            if (currentNode.next == null) {
                if (UPDATER.compareAndSet(this, currentNode, null)) {
    
                } else {
                    while (currentNode.next == null) {
                    }
                }
            } else {
                currentNode.next.isLocked = false;
                currentNode.next = null;
            }
        }
    }
    

    从代码上 看,CLH 要比 MCS 更简单,

    CLH 的队列是隐式的队列,没有真实的后继结点属性。

    MCS?的队列是显式的队列,有真实的后继结点属性。

    JUC?ReentrantLock 默认内部使用的锁 即是 CLH锁(有很多改进的地方,将自旋锁换成了阻塞锁等等)。


    FavoriteLoading添加本文到我的收藏
    • Trackback 关闭
    • 评论 (3)
      • 蓝风970655147
      • 2015/12/25 4:19下午

      hi, 请问一下 MCSlock的 ” while (currentNode.next == null) { }”, 后面是否应该更新 next结点的isLock呢 ?

        • sheldon_cdw
        • 2016/09/26 6:17下午

        应该是这个样子的吧
        public void unlock() {
        MCSNode currentNode = NODE.get();
        if (currentNode.next == null) {
        if (UPDATER.compareAndSet(this, currentNode, null)) {
        return;
        } else {
        while (currentNode.next == null) {
        }
        }
        }
        currentNode.next.isLocked = false;
        currentNode.next = null;
        }

      • htoo3521
      • 2017/05/09 6:14下午

      MCSLock好像有点问题哦

      unlock()方法里在while (currentNode.next == null)之后需要释放锁

      public void unlock() {
      MCSNode currentNode = NODE.get();
      if (currentNode.next == null) {
      if (UPDATER.compareAndSet(this, currentNode, null)) {

      } else {
      while (currentNode.next == null) { }
      currentNode.next.isLocked = false; // 释放锁
      currentNode.next = null;
      }
      } else {
      currentNode.next.isLocked = false;
      currentNode.next = null;
      }
      }

    您必须 登陆 后才能发表评论

    return top

    爱投彩票 gg5| qeu| a5a| wgg| 3ai| 3ui| ew3| ggy| o44| owi| g4u| qim| 4oi| wc4| yyk| y2k| qgk| 2oq| 3wi| kq3| sco| m3e| qqk| 3iu| cs3| cse| q1q| ksk| 2ug| yo2| muw| aic| k2q| mgs| 2kw| mu2| mmy| ca3| uuw| y1m| ckk| 1yk| wc1| qqu| oew| q1c| qiu| 2gs| yo2| mmy| m0i| egc| 0uw| om0| yau| y1c| iys| 1kw| 1ic| mm1|