jdk1.8 ConcurrentHashMap源码阅读

最新推荐文章于 2024-07-09 20:04:21 发布
最新推荐文章于 2024-07-09 20:04:21 发布
阅读量212 收藏
点赞数
分类专栏： java 源码 文章标签： 源码 java 并发 ConcurrentHashMap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nicorui/article/details/89029673
版权
java 同时被 2 个专栏收录
22 篇文章 0 订阅
订阅专栏
源码
2 篇文章 0 订阅
订阅专栏

put方法

  1. 如果没初始化则先初始化数组
  2. 如果数组对应位置上为null，则表示当前参数是数组该位置上的第一个节点，直接调用cas进行插入
  3. 如果数组对应位置上的节点hash值为MOVED，则表示正在进行扩容操作，调用helpTransfer方法帮助一起扩容
  4. 以上都不是则加锁进行节点的增加/更新操作
    • 如果头节点的hash值 >= 0，则表示是链表，循环遍历链表进行增加或删除操作，并累加binCount统计链表长度
    • 否则如果头结点是TreeBin，则表示该位置上的数据结构为红黑树，进行红黑树的增加或删除操作
  5. 判断binCount长度，如果达到阈值TREEIFY_THRESHOLD，则调用treeifyBin方法判断是需要扩容还是转换为红黑树
  6. 增加元素数量
/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
  if (key == null || value == null) throw new NullPointerException();
  int hash = spread(key.hashCode());
  int binCount = 0;
  // 循环获取table是为了put操作如果没有抢占到锁或者cas失败不会导致put失败，会等到下一次继续执行
  for (Node<K,V>[] tab = table;;) {
    Node<K,V> f; int n, i, fh;
    // 如果是第一次put，则初始化tab
    if (tab == null || (n = tab.length) == 0)
      tab = initTable();
    else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
      // 根据传入的key的hash获取tab中的元素赋值给f，如果等于null，则表示tab数组中该位置还没有任何元素，则通过cas添加元素
      if (casTabAt(tab, i, null,
                   new Node<K,V>(hash, key, value, null)))
        break;                   // no lock when adding to empty bin
    }
    // 如果获取到的元素f的hash值等于MOVED，则表示该元素已经在扩容的时候被转移了，那么就调用helpTransfer方法帮助扩容
    else if ((fh = f.hash) == MOVED)
      tab = helpTransfer(tab, f);
    else {
      // 以上都不是，则表示上面根据key的hash值从tab中获取到的f元素是链表或者树
      // 则需要对获取到的f元素加锁进行真正的添加Or更新操作
      V oldVal = null;
      synchronized (f) {
        // 再次判断获取到的f元素是否等于key当前运算之后得到的位置，防止其它线程已经将该元素移动
        if (tabAt(tab, i) == f) {
          // 如果fh大于等于0，则表示是链表的首元素，进行链表元素的增加或者更新操作
          if (fh >= 0) {
            // binCount记录元素的个数
            binCount = 1;
            // 循环遍历链表
            for (Node<K,V> e = f;; ++binCount) {
              K ek;
              // 如果找到key相等的值，则替换该元素的value进行更新
              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;
              // 如果一直遍历到链表末尾都没找到key相等的元素，则创建元素添加到链表末尾
              if ((e = e.next) == null) {
                pred.next = new Node<K,V>(hash, key,
                                          value, null);
                break;
              }
            }
          }
          // 如果fh不是大于等于0，再判断该元素是不是tab(i)位置上的树的根节点，如果是树的根节点，则进行树的增改操作
          // 树的根节点会用常量TREEBIN表示，该值为-2
          else if (f instanceof TreeBin) {
            Node<K,V> p;
            binCount = 2;
            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                  value)) != null) {
              oldVal = p.val;
              if (!onlyIfAbsent)
                p.val = value;
            }
          }
        }
      }
      if (binCount != 0) {
        // 如果binCount，既链表长度大于等于阈值，则调用treeifyBin方法
        // 该方法内部会判断tab数组长度是否大于64，如果大于64，则会转换成红黑树，否则扩容table数组
        if (binCount >= TREEIFY_THRESHOLD)
          treeifyBin(tab, i);
        if (oldVal != null)
          return oldVal;
        break;
      }
    }
  }
  // put操作真正完成之后将count加1
  addCount(1L, binCount);
  return null;
}

初始化方法initTable

/**
 * Initializes table, using the size recorded in sizeCtl.
 */
private final Node<K,V>[] initTable() {
  Node<K,V>[] tab; int sc;
  // 循环是为了cas失败之后继续进行cas抢占操作
  while ((tab = table) == null || tab.length == 0) {
    // 如果sizeCtl < 0 表示有其它线程正在进行初始化，让出cpu
    if ((sc = sizeCtl) < 0)
      Thread.yield(); // lost initialization race; just spin
    // cas操作将SIZECTL设置为-1表示当前线程正在初始化
    else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
      try {
        // 再判断一次防止其它线程已经初始化table
        if ((tab = table) == null || tab.length == 0) {
          // DEFAULT_CAPACITY默认为16，初始化数组长度为输入的或者默认的16
          int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
          @SuppressWarnings("unchecked")
          Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
          table = tab = nt;
          // sc = n * 0.75
          sc = n - (n >>> 2);
        }
      } finally {
        // 设置sizeCtl为阈值
        sizeCtl = sc;
      }
      break;
    }
  }
  return tab;
}

treeifyBin方法

/**
 * Replaces all linked nodes in bin at given index unless table is
 * too small, in which case resizes instead.
 */
private final void treeifyBin(Node<K,V>[] tab, int index) {
  Node<K,V> b; int n, sc;
  if (tab != null) {
    // MIN_TREEIFY_CAPACITY为64，如果数组长度小于这个长度，则进行数组扩容
    if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
      tryPresize(n << 1);
    // 如果不小于MIN_TREEIFY_CAPACITY，并且该位置对应的节点是链表则转换成红黑树
    else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
      synchronized (b) {
        // 双重判定防止并发修改
        if (tabAt(tab, index) == b) {
          // hd为头节点，tl为尾节点
          TreeNode<K,V> hd = null, tl = null;
          // 遍历链表，将链表中的元素转换成TreeNode，转换后的结构还是链表
          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;
          }
          // TreeBin初始化方法是将hd为头节点的链表转换成红黑树
          // 再将转换之后的红黑树塞到数组中对应的位置中去
          setTabAt(tab, index, new TreeBin<K,V>(hd));
        }
      }
    }
  }
}

扩容方法tryPresize

要完全看懂tryPresize方法需要看懂transfer方法，后面会分析transfer方法

/**
* Tries to presize table to accommodate the given number of elements.
*
* @param size number of elements (doesn't need to be perfectly accurate)
*/
private final void tryPresize(int size) {
  // size已经是数组的2倍了，tableSizeFor是将传入的数向上取最近的2的n次方
  // 所以这里的c = 2 * size
  int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
  tableSizeFor(size + (size >>> 1) + 1);
  int sc;
  // (sc = sizeCtl) >= 0表示还未被初始化或还未扩容
  while ((sc = sizeCtl) >= 0) {
    Node<K,V>[] tab = table; int n;
    if (tab == null || (n = tab.length) == 0) {
      n = (sc > c) ? sc : c;
      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;
        }
      }
    }
    // c <= sc表示已经扩容完成，n >= MAXIMUM_CAPACITY表示已经达到最大容量无法扩容
    else if (c <= sc || n >= MAXIMUM_CAPACITY)
      break;
    else if (tab == table) {
      int rs = resizeStamp(n);
      // sc < 0表示正在扩容，那么获取新数组nextTable，帮助一起扩容
      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;
        // 这里需要注意，调用transfer方法之前会将
        if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
          transfer(tab, nt);
      }
      // 如果没有线程在做扩容操作，则当前线程做新数组的初始化并扩容，这里需要注意，第一个进行扩容的线程将SIZECTL设置为(rs << RESIZE_STAMP_SHIFT) + 2
      else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                   (rs << RESIZE_STAMP_SHIFT) + 2))
        transfer(tab, null);
    }
  }
}

transfer方法

  1. 先判断需不需要初始化新数组，如果需要则初始化，stride表示每个线程一次性负责迁移的数组节点个数，transferIndex表示下一个线程负责迁移的数组起始下标，从大到小递减，每次一个线程过来帮助扩容就会减少stride
  2. while循环内部保证线程内下标在transferIndex - 1 到 transferIndex - stride之间移动，还保证线程之间负责的下标以stride进行分割
  3. 每次分配一个数组中的位置则将advance标为true，表示当前位置的迁移工作已经分配，并将对应的位置赋值为fwd，表示该位置的数据已经被迁移
  4. 真正进行迁移的时候会判断是链表还是红黑树，链表则会将链表分成两个，一个迁移到新数组的原下标位置上，另一个分配到新数组新下标位置上。如果是红黑树还会判断拆分后的长度是不是达到阈值，如果没达到则会将红黑树退化成链表
/**
 * Moves and/or copies the nodes in each bin to new table. See
 * above for explanation.
 */
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
  int n = tab.length, stride;
  // 这里的stride表示步长，即每个线程分配stride个数组节点进行扩容
  // NCPU表示cpu核心数，所以这里的意思是总共最多会有cpu核心数个线程共同进行transfer操作
  // 如果分配的stride小于最小值MIN_TRANSFER_STRIDE(即16)，则stride = 16
  if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
    stride = MIN_TRANSFER_STRIDE; // subdivide range
  // 这里进行新数组的初始化操作，将两个类变量nextTable和transferIndex进行赋值，
  // 其实参数中传进来的nextTab就是这里赋值的nextTable传进来的，transferIndex初始化为原始数组的长度
  if (nextTab == null) {            // initiating
    try {
      @SuppressWarnings("unchecked")
      Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
      nextTab = nt;
    } catch (Throwable ex) {      // try to cope with OOME
      sizeCtl = Integer.MAX_VALUE;
      return;
    }
    nextTable = nextTab;
    transferIndex = n;
  }
  int nextn = nextTab.length;
  // 这里初始化一个ForwardingNode节点，用来替换掉当前数组位置tab[i]中的数据
  // 表示当前位置的数据正在进行数据迁移操作，上面get方法中就会判断节点的has是否等于MOVED，
  ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
  // advance表示当前数组位置上的数据是不是正在迁移或者说当前数组位置上的数据迁移工作有没有被分配
  boolean advance = true;
  // finishing表示整体数据有没有迁移完成
  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;
      // 这个判断表示在每一个步长(stride)中将i进行递减，直到该步长用完，就会在第二个判断中判断总长度是否递减为0
      if (--i >= bound || finishing)
        advance = false;
      // 如果该stride长度已经遍历完成，看transferIndex也就是下一次遍历的起始位置是不是为0，为0表示所有数据都已经迁移完成，将赋值为-1
      else if ((nextIndex = transferIndex) <= 0) {
        i = -1;
        advance = false;
      }
      // 如果还没全部遍历完成，则将transferIndex递减一个stride，bound = transferIndex-stride，i = transferIndex - 1，表示本线程开始迁移transferIndex-stride至transferIndex - 1之间的数据
      // 由于这里的transferIndex是volatile修饰的类变量，所以每次修改这个值其它线程都能看到
      // 下一个到达这里的线程就会负责transferIndex-2*stride至transferIndex - stride - 1之间的数据了
      else if (U.compareAndSwapInt
               (this, TRANSFERINDEX, nextIndex,
                nextBound = (nextIndex > stride ?
                             nextIndex - stride : 0))) {
        bound = nextBound;
        i = nextIndex - 1;
        advance = false;
      }
    }
    // 如果不在[0,n)之间，则表示数据迁移可能已经完成了
    if (i < 0 || i >= n || i + n >= nextn) {
      int sc;
      if (finishing) {
        nextTable = null;
        table = nextTab;
        sizeCtl = (n << 1) - (n >>> 1);
        return;
      }
      // 这里需要结合调用transfer方法的那块代码看，每次调用transfer之前都会将SIZECTL + 1，这里表示每个线程完成了迁移就将SIZECTL - 1
      if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
        // 第一次调用transfer的时候会将SIZECTL赋值为(resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2，所以这里判断SIZECTL是不是已经递减到原始值，如果是则表示所有线程都完成了数据迁移，退出整个方法
        if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
          return;
        finishing = advance = true;
        i = n; // recheck before commit
      }
    }
    // 如果没迁移完成，并且当前数组位置的值==null，则将当前位置塞入fwd，表示当前位置的数据正在迁移
    else if ((f = tabAt(tab, i)) == null)
      advance = casTabAt(tab, i, null, fwd);
    else if ((fh = f.hash) == MOVED)
      advance = true; // already processed
    else {
      synchronized (f) {
        // 双重校验
        if (tabAt(tab, i) == f) {
          // 这里的ln是转移到新数组原来下标上的链表，hn是转移到新数组新下标位置的链表
          Node<K,V> ln, hn;
          // fh >= 0表示tab[i]位置上的是个链表
          if (fh >= 0) {
            int runBit = fh & n;
            Node<K,V> lastRun = f;
            // 这段循环是为了找出 最后 连续的能分配到相同下标上的链表
            for (Node<K,V> p = f.next; p != null; p = p.next) {
              int b = p.hash & n;
              if (b != runBit) {
                runBit = b;
                lastRun = p;
              }
            }
            // node.hash & n == 0则表示node.hash & (2n - 1) < 16
            // 举个栗子：设n = 16即原数组长度为16，二进制表示为n = 0000....10000，2n - 1 = 0000....11111，那么node.hash & n == 0则该hash可以表示为****....0****
            
            // ******** ******** ******** ***0****	node.hash
            // 00000000 00000000 00000000 00010000 	n
            // 00000000 00000000 00000000 00000000 	= 0
            
            // ******** ******** ******** ***0**** 	node.hash
            // 00000000 00000000 00000000 00011111 	2n - 1
            // 00000000 00000000 00000000 0000**** 	< 16
            if (runBit == 0) {
              ln = lastRun;
              hn = null;
            }
            else {
              hn = lastRun;
              ln = null;
            }
            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，表示该位置的数据已经迁移
            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;
            // 遍历TreeNode链表构建两个新的TreeNode链表
            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);
              // (h & n) == 0表示该节点在新数组中的原始下标
              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;
              }
            }
            // 判断两个新链表的长度是不是 <= UNTREEIFY_THRESHOLD，如果是则转换为Node链表，否则构建红黑树
            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;
          }
        }
      }
    }
  }
}

get方法

/**
* Returns the value to which the specified key is mapped,
* or {@code null} if this map contains no mapping for the key.
*
* <p>More formally, if this map contains a mapping from a key
* {@code k} to a value {@code v} such that {@code key.equals(k)},
* then this method returns {@code v}; otherwise it returns
* {@code null}.  (There can be at most one such mapping.)
*
* @throws NullPointerException if the specified key is null
*/
public V get(Object key) {
  Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
  int h = spread(key.hashCode());
  if ((tab = table) != null && (n = tab.length) > 0 &&
      (e = tabAt(tab, (n - 1) & h)) != null) {
    // 如果头节点是我们要找的则直接返回
    if ((eh = e.hash) == h) {
      if ((ek = e.key) == key || (ek != null && key.equals(ek)))
        return e.val;
    }
    // eh < 0表示正在扩容或者是红黑树，则调用节点的find方法查找，各种节点会实现各自的find方法
    else if (eh < 0)
      return (p = e.find(h, key)) != null ? p.val : null;
    // 否则遍历链表找到节点
    while ((e = e.next) != null) {
      if (e.hash == h &&
          ((ek = e.key) == key || (ek != null && key.equals(ek))))
        return e.val;
    }
  }
  return null;
}
OverrideRe
关注
专栏目录
JDK1.8ConcurrentHashMap源码解析第二部分（添加元素、删除元素、扩容、查找元素）
weixin_43478710的博客
11-13 1190
ConcurrentHashMap源码解析第二部分，着重分析ConcurrentHashMap添加元素、删除元素、扩容、查找元素的具体流程 1、添加元素 添加元素用到的是putVal方法 public V put(K key, V value) { return putVal(key, value, false); } //onlyIfAbsent为true时找到相同节点不替换 为false就替换 final V putVal(K key, V value, boolean onlyIfA
jdk 1.8 ConcurrentHashMap和1.7 ConcurrentHashMap区别 原理解析
xqqTechnology的博客
05-31 656
@[TOC](`jdk 1.8 ConcurrentHashMap和1.7 ConcurrentHashMap区别 原理解析） #在上一篇文章中，我们详细链接了HashMap在1.7和1.8和实现区别，但是我们都知道HashMap在多线程下是不安全的，所以jdk也为我们提供了并发安全的容器进行使用，那就是我们这篇文章的主角：ConcurrentHashMap。 part1：1.7ConcurrentHashMap探索 我们首先看一下内部结构 从源码我们了解到，ConcurrentHashMap 是
阿里面试官经常问的 HashMap 和 ConcurrentHashMap，相信看完这篇没有人能再难住你。
沉默王二
09-01 5218
通过源码深度剖析 ConcurrentHashMap，透彻地比较了 Java 7 和 Java 8 之间的不同。
ConcurrentHashMap静态公共方法分析
TheAnnoyingDog的博客
10-23 486
分析ConcurrentHashMap中一些重要的公共方法，以便理解后面的源码。
HashMap/ConcurrentHashMap详解
少年乖
05-28 4508
一、HashMap1.HashMap本质是一个数组，数组的每个元素都是一个单链表。java源码中，这个数组就是table，其定义如下：transient Node&lt;K,V&gt;[] table;//table数组，每个数组元素都是一个链表，链表由0个或多个节点组成节点类定义如下，注释中解释此类：//静态内部类的特点：在创建静态内部类的实例时，不必创建外部类的实例 static class ...
深度剖析ConcurrentHashMap
leixingbang的专栏
10-04 1200
还记得大学快毕业的时候要准备找工作了，然后就看各种面试相关的书籍，还记得很多面试书中都说到： HashMap是非线程安全的，HashTable是线程安全的。 那个时候没怎么写Java代码，所以根本就没有听说过ConcurrentHashMap，只知道面试的时候就记住这句话就行了...至于为什么是线程安全的，内部怎么实现的，通通不了解。 今天我们将深入剖析一个比HashTa
ConcurrentHashMap之spread、tabAt、casTabAt、setTabAt、resizeStamp、tableSizeFor
lxsxkf的博客
01-17 2191
5.1——spread(hash) 源码分析 / * 1100 0011 1010 0101 0001 1100 0001 1110 * 0000 0000 0000 0000 1100 0011 1010 0101 * 1100 0011 1010 0101 1101 1111 1011 1011 * --------------------------------------- * 1100 0011 1010 0101 1101 1111 1011
jdk1.8 ConcurrentHashMap 源码分析
最新发布
weixin_42710740的博客
07-09 345
ConcurrentHashMap 1.8 使用synchronized 和CAS 实现。记住：1.8没有分段锁不要混淆了，分段锁是1.7中的。
JDK1.8 ConcurrentHashMap源码笔记
bcpx819的博客
02-08 213
JDK1.8 ConcurrentHashMap源码笔记
JDK1.8中ConcurrentHashMap源码解析
小志的博客
11-16 1547
目录一、ConcurrentHashMap使用场景二、put方法的整体流程三、第一种情况（初始化table数组）1、initTable源码如下：2、sizeCtl3、流程解释四、第二种情况（寻址后的位置没有被占用）1、源码如下 一、ConcurrentHashMap使用场景 我们平时最常用的HashMap其实不是线程安全的，而当我们有多线程使用场景的时候，即想线程安全，又想拥有Map的能力，我们可以选择HashTable，因为它是针对我们常用的方法上面加上了synchronize锁，但是在高并发的场景下
JDK1.8 ConcurrentHashMap的一点理解
01-07
只是都是相通的，当我们了解了ConcurrentHashMap的实现原理以及各个方法的实现机制，我们对于其他的hash类型实现也能快速的理解，今天我们就来通过源码来一点一点的分析下ConcurrentHashMap的实现。 首先我们来看...
JDK1.8ConcurrentHashMap.md
09-11
对JDK8中ConcurrentHashMap的容器初始化、添加元素安全、扩容安全以及多线程情况下扩容效率的提高、集合长度的累计方式以及获取集合长度等这些方法的源码进行了详细的解释说明
JDK1.8:JDK1.8源码解析-源码解析
03-24
在深入探讨JDK1.8源码解析之前，先理解一下JDK的含义：Java Development Kit，即Java开发工具包，是Java编程语言的核心组成部分，提供了编写、编译和运行Java应用程序所需的所有工具。JDK1.8是Oracle公司发布的Java ...
Java自带的XML解析
OverrideRe的博客
11-27 3269
JAXP (Java API for XML Processing,意为处理XML的Java API) 解析XML一般有两种方式: 一种是DOM方式:一次性读取XML内容存入内存 优点:能进行各种增删改查的操作 确定:占用内存大 使用:给定需要读取的文件即可读取,读取出来之后再根据自己写的方法进行操作 还有一种是SAX方式:顺序读取内容,碰到什么样的标签执行什么样的操作由自己定义
SSM框架整合（IntellIj IDEA+Maven+Spring+SpringMVC+MyBatis）之MyBatis
OverrideRe的博客
07-06 2616
我认为框架整合不熟练的话按照MyBatis->SpringMVC->Spring顺序整合比较好，先配置MyBatis是因为不需要额外的配置服务器，进行单元测试比较容易。Spring是用来进行整合的，所以等其它框架配置好之后进行整合不会显得很乱。IntelliJ IDEA搭建Maven项目新建完项目之后就是下面这样一个空项目 按规范搭建一个项目结构，src下面分为main和test，main放正式代
垃圾收集器
OverrideRe的博客
04-13 2183
垃圾收集器与内存分配策略概述垃圾收集器（Garbage Collection，GC）需要解决的三个问题： 哪些内存需要回收？ 什么时候回收？ 如何回收？ 前面介绍了Java内存运行时区域的各个部分，其中程序计数器、虚拟机栈和本地方法栈三个区域随线程而生，随线程而灭；栈中的栈帧随着方法的进入和退出而有条不紊地执行着出栈和入栈操作。因此这几个区域的内存分配和回收都具备确定性，不需要过多考虑回收的问题。而
SSM框架整合（IntellIj IDEA+Maven+Spring+SpringMVC+MyBatis）之Spring Framework
OverrideRe的博客
07-06 1938
1.配置SpringMVC1.1编写Spring配置文件applicationContext.xml<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springfra
Spring学习,依赖注入(DI)、控制反转(IoC)和面向切面(AOP)
OverrideRe的博客
02-13 1916
依赖注入DI和控制反转IoC Spring容器中的依赖注入DI和控制反转IoC xml配置 注解配置 面向切面AOP 面向切面的应用动态代理 Spring容器中的面向切面 xml配置 注解配置 Spring整合hibernate和AOP应用之声明式事务依赖注入(DI)和控制反转(IoC)在日常编码中经常遇到在一个类中调用另一个类的多个方法，所以就在一个类中new出需要用到的类，也就是组合模式。比如说
Java Class文件结构
OverrideRe的博客
04-06 1616
平台无关性和语言无关性Java在刚刚诞生的时候提出过一个宣传口号：“一次编写，到处运行”，这句话充分表达了软件开发人员对冲破平台界限的渴求。“与平台无关”的理想最终实现在操作系统的应用层上：Sun公司及其他虚拟机提供商发布了许多可以运行在各种不同平台上的虚拟机，这些虚拟机都可以载入和执行同一种平台无关的字节码，从而实现了程序的“一次编写，到处运行”。 各种不同平台的虚拟机与所有平台都统一使用的程序
JDK 1.8 ConcurrentHashMap 源码分析：初始化和构造方法
在 JDK 1.8 中，ConcurrentHashMap 的实现有了很大的变化，本文将对 ConcurrentHashMap 的源码进行分析。 一、构造方法 ConcurrentHashMap 的构造方法有五个，分别是： 1. `public ConcurrentHashMap()`：无参...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值