ConcurrentHashMap

这个能看懂的都是大佬了

反正我是看懂了一部分，但是对于一些跳出循环呀，跳出if判断的还是很模糊，不过不影响对于hash表整体的理解

有完全搞明白的大佬可以指点一波

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {
 	//最大容量
   private static final int MAXIMUM_CAPACITY = 1 << 30;
 	private static final int DEFAULT_CAPACITY = 16;
 	static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
   //默认并发度  但是貌似没啥用
   private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
   private static final float LOAD_FACTOR = 0.75f;
   static final int TREEIFY_THRESHOLD = 8;
   static final int UNTREEIFY_THRESHOLD = 6;
   static final int MIN_TREEIFY_CAPACITY = 64;
   //以下的含义没搞明白  只知道在各种比较运算中用到了   - ，
   private static final int MIN_TRANSFER_STRIDE = 16;
   private static int RESIZE_STAMP_BITS = 16;
   private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
   private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
   
   /*---------------------------------fields-----------------------------*/
   //存放数据的hash表
   transient volatile Node<K,V>[] table;
   //扩容的时候，会将以前的表的数据让在这个 
   // 扩容完成之后，会将这个置为null，同时将表赋值给上面的table
   //注意：在扩容的时候，会将正在扩容的结点的索引的结点的hash值设置成MOVED=-1 
   //在添加数据的时候，就会判断该位置是不是在扩容，如果是，会加入到扩容的任务中
   private transient volatile Node<K,V>[] nextTable;
   //map的大小
   private transient volatile long baseCount;
   //扩容阙值
   private transient volatile int sizeCtl;
   //扩容的时候数据迁移的具体的索引
   private transient volatile int transferIndex;
   private transient volatile int cellsBusy;
   //一个数组，用来辅助统计map的大小
   private transient volatile CounterCell[] counterCells;

    
    /*--------------------method------------------*/
    
    public ConcurrentHashMap() {
    }
    public ConcurrentHashMap(int initialCapacity) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException();
        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY : tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
        this.sizeCtl = cap;
    }
    public ConcurrentHashMap(int initialCapacity, float loadFactor) {
        this(initialCapacity, loadFactor, 1);
    }
    
    public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        if (initialCapacity < concurrencyLevel)   // Use at least as many bins
            initialCapacity = concurrencyLevel;   // as estimated threads
        long size = (long)(1.0 + (long)initialCapacity / loadFactor);
        int cap = (size >= (long)MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : tableSizeFor((int)size);
        this.sizeCtl = cap;
    }
    
    //还是从放入值开始分析  构造函数只是初始化了基本的容量 从put来分析每一个变量的作用
    //给hash表中放入数据
    public V put(K key, V value) {
        return putVal(key, value, false);
    }
    final V putVal(K key, V value, boolean onlyIfAbsent) {
        //key value都不能为null   hashmap是可以存放null值的
        if (key == null || value == null) throw new NullPointerException();
        //计算hash值 这一块与hashmap有点区别， 这一块多了一次跟HASH_BITS的与运算
        int hash = spread(key.hashCode());
        //记录节点数，用来树化的判断
        int binCount = 0;
        //循环遍历hash表
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            //hash表为空，初始化hash表
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            //初始化完成之后，第二次循环就会来判断这里
            //计算需要存放的索引 并判断这个索引位置有没有结点
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                //当前索引位置为空，以cas算法创建节点并插入这个位置   
                //如果cas失败了，也就是发生了hash冲突  那么会进入下一次循环，那么代码就会走到下面的判断了
                if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
                    //插入结束
                    break;                   // no lock when adding to empty bin
            }
            //可能在添加的时候，其他线程也正在进行扩容等操作
            //在扩容的时候，会将所有的hash值都设置为moved  等待扩容完成之后，会将本链表删除并返回新的扩容值后的链表
            else if ((fh = f.hash) == MOVED)
                //帮助扩容
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                //加锁  注意这个锁的对象是具体的一个node结点！也就是锁的粒度精确到了某一个entry结点，而不是锁整个链表
                synchronized (f) {
                    //如果f结点是第一个结点
                    if (tabAt(tab, i) == f) {
                        //f结点的hash值>=0  也就是链表结构
                        if (fh >= 0) {
                            //记录节点数量
                            binCount = 1;
                            //遍历结点
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                //遍历中的结点的key与我们要插入的key相同
                                if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) {
                                    //保存旧值
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        //替换新值
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    //遍历中的结点不存在下一个结点，那么就创建新的节点,挂在到链表中
                                    pred.next = new Node<K,V>(hash, key, value, null);
                                    break;
                                }
                            }
                        }
                        //如果这个索引存放的是树结点
                        else if (f instanceof TreeBin) {
                            Node<K,V> p;
                            binCount = 2;
                            //添加树节点 内部会判断树中有没有与我们需要添加的key相同的结点  没有直接添加返回null 有的话返回结点
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                if (binCount != 0) {
                    //判断是不是需要树化
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        //返回旧结点
                        return oldVal;
                    break;
                }
            }
        }
        //map的长度+1
        addCount(1L, binCount);
        return null;
    }
    
    //69行详解   第一次添加元素的时候，初始化hash表
    private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) {
            //当sizeCtl小于0的时候，线程让出cpu执行权， 但不能保证本线程不会抢到cpu
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin
            //cas算法，判断sizeCtl的值有没有发生变化，并且把它设置成 -1  也就是代表本线程要初始化table，其他线程就不能操作了
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    //再次确认table没有被初始化
                    if ((tab = table) == null || tab.length == 0) {
                        //设置表的长度
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        @SuppressWarnings("unchecked")
                        //初始化表
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = tab = nt;
                        //设置sc的值
                        sc = n - (n >>> 2);
                    }
                } finally {
                    //将sc赋值给sizeCtl  目前来看，这个sizeCtl跟hashmap里面的扩容阙值是一个意义
                    sizeCtl = sc;
                }
                break;
            }
        }
        //返回初始化完成的表
        return tab;
    }
    
    //扩容
    private final void tryPresize(int size) {
        //计算新表长度
        int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY : tableSizeFor(size + (size >>> 1) + 1);
        int sc;
        //扩容阙值>=0的判断
        while ((sc = sizeCtl) >= 0) {
            Node<K,V>[] tab = table; int n;
            //hash表为空
            if (tab == null || (n = tab.length) == 0) {
                n = (sc > c) ? sc : c;
                //cas进行判断
                if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                    try {
                        //还没有其他线程对表做修改
                        if (table == tab) {
                            @SuppressWarnings("unchecked")
                            //初始化表
                            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                            table = nt;
                            //重新计算扩容阙值
                            sc = n - (n >>> 2);
                        }
                    } finally {
                        //设置扩容阙值
                        sizeCtl = sc;
                    }
                }
            }
            //表的长度超过最大容量，直接退出循环
            else if (c <= sc || n >= MAXIMUM_CAPACITY)
                break;
            //表数据还有转移完成   为什么这么说呢  因为这个可以有多个线程来帮助去进行数据转移，而不是一个线程去做迁移
            else if (tab == table) {
                int rs = resizeStamp(n);
                if (sc < 0) {
                    Node<K,V>[] nt;
                    if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || sc == rs + MAX_RESIZERS || (nt = nextTable) == null || transferIndex <= 0)
                        break;
                    if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                        扩容  数据转移
                        transfer(tab, nt);
                }
                else if (U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2))
                    //扩容  数据转移
                    transfer(tab, null);
            }
        }
    }
    
    private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        int n = tab.length, stride;
        //stride可以理解为步长，将需要转移的数据拆分成stride个任务，让多个线程去处理
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; // subdivide range
        //初始化nextTab
        if (nextTab == null) {            // initiating
            try {
                @SuppressWarnings("unchecked")
                //创建一个长度是旧表长度2倍的数组
                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
                //将他赋值给nwxtTab
                nextTab = nt;
            } catch (Throwable ex) {      // try to cope with OOME
                sizeCtl = Integer.MAX_VALUE;
                return;
            }
            nextTable = nextTab;
            //transferIndex 也是 ConcurrentHashMap 的属性，用于控制迁移的位置
            transferIndex = n;
        }
        int nextn = nextTab.length;
        //正在被迁移的node  原数组中位置 i 处的节点完成迁移工作后，就会将位置 i 处设置为这个 ForwardingNode，用来告诉其他线程该位置已经处理过了

        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
        //advance 指的是做完了一个位置的迁移工作，可以准备做下一个位置的了
        boolean advance = true;
        boolean finishing = false; // to ensure sweep before committing nextTab
        for (int i = 0, bound = 0;;) {
            Node<K,V> f; int fh;
            while (advance) {
                int nextIndex, nextBound;
                if (--i >= bound || finishing)
                    advance = false;
                //这里 transferIndex 一旦小于等于 0，说明原数组的所有位置都有相应的线程去处理了
                else if ((nextIndex = transferIndex) <= 0) {
                    i = -1;
                    advance = false;
                }
                //看括号中的代码，nextBound 是这次迁移任务的边界，注意，是从后往前
                else if (U.compareAndSwapInt(this, TRANSFERINDEX, nextIndex, nextBound = (nextIndex > stride ? nextIndex - stride : 0))) {
                    bound = nextBound;
                    i = nextIndex - 1;
                    advance = false;
                }
            }
            if (i < 0 || i >= n || i + n >= nextn) {
                int sc;
                // 所有的迁移操作已经完成
                if (finishing) {
                    nextTable = null;
                    // 将新的 nextTab 赋值给 table 属性，完成迁移
                    table = nextTab;
                    //计算下一次扩容阙值
                    sizeCtl = (n << 1) - (n >>> 1);
                    return;
                }
                //sizeCtl 在迁移前会设置为 (rs << RESIZE_STAMP_SHIFT) + 2
                //每有一个线程参与迁移就会将 sizeCtl 加 1
                //这里使用 CAS 操作对 sizeCtl 进行减 1，代表做完了属于自己的任务
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                    //所有任务都完成了  将finishing改成true
                    finishing = advance = true;
                    i = n; // recheck before commit
                }
            }
            //如果位置 i 处是空的，没有任何节点，那么放入刚刚初始化的 ForwardingNode ”空节点“
            else if ((f = tabAt(tab, i)) == null)
                advance = casTabAt(tab, i, null, fwd);
            //该位置处是一个 ForwardingNode，代表该位置已经迁移过了
            else if ((fh = f.hash) == MOVED)
                //有空余线程可以去处理数据迁移，将这个值设置为true
                advance = true; // already processed
            else {
                //对数组该位置处的结点加锁，开始处理数组该位置处的迁移工作
                synchronized (f) {
                    //再次检查结点是否还没被迁移
                    if (tabAt(tab, i) == f) {
                        Node<K,V> ln, hn;
                        if (fh >= 0) {
                            int runBit = fh & n;
                            Node<K,V> lastRun = f;
                            //循环遍历结点，找到lastRun 也就是根据指定的算法将链表分为p-lastRun的上一个结点   与lastRun之后的结点
                            for (Node<K,V> p = f.next; p != null; p = p.next) {
                                int b = p.hash & n;
                                if (b != runBit) {
                                    runBit = b;
                                    lastRun = p;
                                }
                            }
                            if (runBit == 0) {
                                ln = lastRun;
                                hn = null;
                            }
                            else {
                                hn = lastRun;
                                ln = null;
                            }
                            //继续循环，将p-lastRun之间的结点根据指定的判断逻辑分为两部分，并挂在到ln与hn上
                            for (Node<K,V> p = f; p != lastRun; p = p.next) {
                                int ph = p.hash; K pk = p.key; V pv = p.val;
                                if ((ph & n) == 0)
                                    ln = new Node<K,V>(ph, pk, pv, ln);
                                else
                                    hn = new Node<K,V>(ph, pk, pv, hn);
                            }
                            //将挂在好的结点放入链表中
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            //将原数组该位置处设置为 fwd，代表该位置已经处理完毕
                            //其他线程一旦看到该位置的 hash 值为 MOVED，就不会进行迁移了
                            setTabAt(tab, i, fwd);
                            //该线程任务处理完，可以参与到后续的数据迁移过程中
                            advance = true;
                        }
                        //这一块处理逻辑与上面类似 不过是以树的方法去处理
                        else if (f instanceof TreeBin) {
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> lo = null, loTail = null;
                            TreeNode<K,V> hi = null, hiTail = null;
                            int lc = 0, hc = 0;
                            for (Node<K,V> e = t.first; e != null; e = e.next) {
                                int h = e.hash;
                                TreeNode<K,V> p = new TreeNode<K,V>
                                    (h, e.key, e.val, null, null);
                                if ((h & n) == 0) {
                                    if ((p.prev = loTail) == null)
                                        lo = p;
                                    else
                                        loTail.next = p;
                                    loTail = p;
                                    ++lc;
                                }
                                else {
                                    if ((p.prev = hiTail) == null)
                                        hi = p;
                                    else
                                        hiTail.next = p;
                                    hiTail = p;
                                    ++hc;
                                }
                            }
                            //判断节点数量是否达到树化的阙值  没有就退化 有就树化
                            //注意！树化的时候，创建了一个new TreeBin结点 这个结点里面有两个属性很重要!
                            //第一个属性是hash  他的值是-2
                            //第二个属性是root  这个root才是真正的树的根节点！ 这也就是为什么上面去判断hash值<0就直接认为他是树结点的原因
                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                                (hc != 0) ? new TreeBin<K,V>(lo) : t;
                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                                (lc != 0) ? new TreeBin<K,V>(hi) : t;
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                    }
                }
            }
        }
    }
     //树化
    private final void treeifyBin(Node<K,V>[] tab, int index) {
        Node<K,V> b; int n, sc;
        if (tab != null) {
            //表的长度不超过最小树化值 就去扩容
            if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
                tryPresize(n << 1);
            else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
                synchronized (b) {
                    //再次判断这个索引的结点是不是已经被处理过了
                    if (tabAt(tab, index) == b) {
                        TreeNode<K,V> hd = null, tl = null;
                        //循环遍历节点
                        for (Node<K,V> e = b; e != null; e = e.next) {
                            //将结点包装成树结点
                            TreeNode<K,V> p = new TreeNode<K,V>(e.hash, e.key, e.val,null, null);
                            if ((p.prev = tl) == null)
                                //设置头节点
                                hd = p;
                            else
                               //保存结点的链表顺序
                                tl.next = p;
                            tl = p;
                        }
                        //更新索引处的结点  并且设置改结点的树关系 也就是设置树的左子树，右子树
                        setTabAt(tab, index, new TreeBin<K,V>(hd));
                    }
                }
            }
        }
    }
    //设置树结点的关系
    TreeBin(TreeNode<K,V> b) {
        //
        super(TREEBIN, null, null, null);
        this.first = b;
        //根节点
        TreeNode<K,V> r = null;
        for (TreeNode<K,V> x = b, next; x != null; x = next) {
            next = (TreeNode<K,V>)x.next;
            x.left = x.right = null;
            if (r == null) {
                x.parent = null;
                x.red = false;
                r = x;
            }
            else {
                K k = x.key;
                int h = x.hash;
                Class<?> kc = null;
                //遍历根节点
                for (TreeNode<K,V> p = r;;) {
                    int dir, ph;
                    K pk = p.key;
                    //判断p结点的key的hash与需要插入到树中的结点的key的hash的大小
                    if ((ph = p.hash) > h)
                        dir = -1;
                    else if (ph < h)
                        dir = 1;
                    else if ((kc == null &&
                              (kc = comparableClassFor(k)) == null) ||
                             (dir = compareComparables(kc, k, pk)) == 0)
                        dir = tieBreakOrder(k, pk);
                        TreeNode<K,V> xp = p;
                    //根据hash值的大小选择是插入到左子树还是右子树  并且这个子树为空
                    if ((p = (dir <= 0) ? p.left : p.right) == null) {
                        //设置需要加如到树中的结点的父节点
                        x.parent = xp;
                        //将结点挂到树种
                        if (dir <= 0)
                            xp.left = x;
                        else
                            xp.right = x;
                        //平衡树  也就是经典的红黑树的旋转变色
                        r = balanceInsertion(r, x);
                        break;
                    }
                }
            }
        }
        //设置根节点
        this.root = r;
        //树的结构校验  是否是红黑树等
        assert checkInvariants(root);
    }
    
    
    //获取值   这一块还是相对简单的
    public V get(Object key) {
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
        //还是首先计算hash值
        int h = spread(key.hashCode());
        //计算索引，并判断索引位置有没有数据
        if ((tab = table) != null && (n = tab.length) > 0 && (e = tabAt(tab, (n - 1) & h)) != null) {
            //如果当前索引出的结点的hash值与key的hash值相同，
            if ((eh = e.hash) == h) {
                //判断是不是同一个key
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    //是相同的key，直接返回
                    return e.val;
            }
            //如果当前结点的hash值小于0，那么这个索引的结点都是树结点
            else if (eh < 0)
                //从树中找指定结点  但是树也是继承于node结点，也有指向下一个next的结点，这一块的查找源码跟下面的一模一样  我也好奇为啥不是二分查找
                return (p = e.find(h, key)) != null ? p.val : null;
            //否则，这个结点就是链表结点，循环遍历来找这个key
            while ((e = e.next) != null) {
                if (e.hash == h && ((ek = e.key) == key || (ek != null && key.equals(ek))))
                    return e.val;
            }
        }
        return null;
    }
    //移除指定的key
    final V replaceNode(Object key, V value, Object cv) {
        //计算hash值
        int hash = spread(key.hashCode());
        //遍历hash表
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            //hash表为空  直接返回
            if (tab == null || (n = tab.length) == 0 || (f = tabAt(tab, i = (n - 1) & hash)) == null)
                break;
            //如果该位置正在进行扩容值后的数据迁移  就加入到任务去进行数据迁移
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                boolean validated = false;
                synchronized (f) {
                    //获取链表头节点
                    if (tabAt(tab, i) == f) {
                        //是链表
                        if (fh >= 0) {
                            validated = true;
                            //遍历链表
                            for (Node<K,V> e = f, pred = null;;) {
                                K ek;
                                //查找指定key的结点
                                if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) {
                                    //获取结点值
                                    V ev = e.val;
                                    //我们删除key的时候 肯定会进入这个判断的  因为cv穿的是null
                                    if (cv == null || cv == ev || (ev != null && cv.equals(ev))) {
                                        //结点值与cv值相等  缓存这个结点的值
                                        oldVal = ev;
                                        //需要删除的value不为空 我们删除key的时候 不会进入这个判断的  因为value传的是null
                                        if (value != null)
                                           //将节点值更新
                                            e.val = value;
                                        else if (pred != null)
                                            //将上一个结点的next指标指向e结点的下一个结点
                                            pred.next = e.next;
                                        else
                                            //走到这一步，说明删除的结点是第一个结点 
                                            //将e的下一个节点放在表的i索引位置 也就相当于删除了e结点
                                            setTabAt(tab, i, e.next);
                                    }
                                    break;
                                }
                                //临时缓存上一个结点
                                pred = e;
                                //将指针后移  继续遍历后面的结点
                                if ((e = e.next) == null)
                                    break;
                            }
                        }
                        //树节点的移除跟链表大同小异 就不做详细分析了
                        else if (f instanceof TreeBin) {
                            validated = true;
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> r, p;
                            //查找需要删除的结点
                            if ((r = t.root) != null && (p = r.findTreeNode(hash, key, null)) != null) {
                                V pv = p.val;
                                if (cv == null || cv == pv || (pv != null && cv.equals(pv))) {
                                    oldVal = pv;
                                    if (value != null)
                                        p.val = value;
                                    //删除查找出来的结点  这一块内部加了锁  锁使用的对象是树的根节点
                                    //内部代码有一段是这么判断的  分析这一块可以得到，树的结点<4才会退化成链表
                                    /*
                                    if ((r = root) == null || r.right == null || (rl = r.left) == null || rl.left == null)
                                    */ 
                                    else if (t.removeTreeNode(p))
                                        setTabAt(tab, i, untreeify(t.first));
                                }
                            }
                        }
                    }
                }
                if (validated) {
                    if (oldVal != null) {
                        if (value == null)
                            addCount(-1L, -1);
                        return oldVal;
                    }
                    break;
                }
            }
        }
        return null;
    }
}