java之HashMap

最新推荐文章于 2022-06-25 11:25:06 发布

kaikai7654321

最新推荐文章于 2022-06-25 11:25:06 发布

阅读量164

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/kaka0930/article/details/82779950

版权

java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

多线程成环

void transfer(Entry[] newTable)
{ Entry[] src = table; int newCapacity = newTable.length; //下面这段代码的意思是： // 从OldTable里摘一个元素出来，然后放到NewTable中 
for (int j = 0; j < src.length; j++)
{
Entry<K,V> e = src[j];
if (e != null)
{
src[j] = null; 
do { Entry<K,V> next = e.next; 
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
} while (e != null); } } }

这段代码的关键要理解多线程的内存模型，其实就是堆是公共的，栈不是。还有，多个线程执行同一个方法，方法内部新生产的变量是不会共享的。

具体过程可以参考这个： https://blog.csdn.net/chisunhuang/article/details/79041656

其实就是线程A再B已经装好的情况下进行操作，这时候e和next不仅会是原来table指向的，还是新table指向，因为内存只有一个，不过reference有两个。另外，每个node的next再堆里面。所以会形成环。因为经过一次重排，顺序刚好反了，再排一次，就环了。

之所以成环之后put不会无限循环，关键在于第一个线程挂起的时间：Entry<K,V> next = e.next; ，这个时候执行完另一个再来执行这个，这个只剩下next和e；当然，每一个链表是放在堆里面的，应该是互相影响的。确实是相互影响的。比如上面的例子里面，最后一个数字在线程1里面不会出现。但是因为之前的线程2已经把这个数字放好了。

形成的环进行get的时候，突然发现无限循环。

其实所谓的线程不安全，无非就是在增删改查的时候，会出现问题，但是必须是多个线程同时进行同一个操作；如果操作不同，就不是线程安全可以解决的了，ConcurrentHashMap也解决不了，比如，一个线程读取了hashmap,但是另一个线程同时进行修改，那么前一个线程读取的数据就可以说是多线程。这种估计要在使用map的时候，对map进行加锁。上面就是同时插入的时候，

加锁可以解决有的线程读，有的线程写的问题。因为所谓加锁，锁的并不是方法，而是对象。同一个对象，concurrentHashmap的时候肯定会锁对象资源。

2、多线程put时可能导致元素丢失

原因：当多个线程同时执行addEntry(hash,key ,value,i)时，如果产生哈希碰撞，导致两个线程得到同样的bucketIndex去存储，就可能会发生元素覆盖丢失的情况

//转移数据
    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {
            while(null != e) {
                Entry<K,V> next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
                //注意
                e.next = newTable[i];
                //注意
                newTable[i] = e;
                e = next;
            }
        }

在put的时候肯定会判断这个key对于的是不是空的，如果空的就直接赋值，不是空的就链表；这是就会重复覆盖。如果按照key-value都是1-1这样的数字，那么只会多不会少。也就是1000以内put，会多余1000，但是还是不到2000.

其实，transfer的源码是不断变化的，这个版本和上个版本就不一样。应该是之前的版本。现在java8也和这不同。最上面那种还有put进去但是get为空的情况，下面这种就没有了。而java8已经不会成环了。但是数据丢失还是会有。

修改也是put，和新增一样。

get的话，并发是没有问题的。

3. hashmap的api说明：

hash允许null key和null value, HashTable不允许。

map赋值给iterator之后，如果修改，就报错。这个要测试。

/**
      * 测试fail-fast的
      */
     public void failfastTest() {
          Map<Integer, String> map = new HashMap<Integer, String>();
          map.put(1, "one");
          map.put(2, "two");
          map.put(3, "three");
          Iterator iter = map.entrySet().iterator();
          map.remove(1);
          while (iter.hasNext()) {
              System.out.println(iter.next());
          }
     }

报错：

ConcurrentModificationException

Node是HashMap的一个内部类，实现了Map.Entry接口，本质是就是一个映射(键值对)。上图中的每个黑色圆点就是一个Node对象。

4. modeCount

size这个字段其实很好理解，就是HashMap中实际存在的键值对数量。注意和table的长度length、容纳最大键值对数量threshold的区别。而modCount字段主要用来记录HashMap内部结构发生变化的次数，主要用于迭代的快速失败。强调一点，内部结构发生变化指的是结构发生变化，例如put新键值对，但是某个key对应的value值被覆盖不属于结构变化。

5. hash

关于hashmap的hash里面的key取一个质数，因为质数更保险，取别的数字也许会遇到危险https://blog.csdn.net/single6/article/details/81353084

hash非常巧妙，它通过h & (table.length -1)来得到该对象的保存位，而HashMap底层数组的长度总是2的n次方，这是HashMap在速度上的优化。当length总是2的n次方时，h& (length-1)运算等价于对length取模，也就是h%length，但是&比%具有更高的效率。因为length是2的n次方，减一所有低位由0变1.

再put调用的putvalue里面，调用了hash，并且，还有一部是（n-1）& hash

因为h&(length-1)保留了length位以下的。相当于取模

其实就是三步，

所谓hash，就是在put的时候和get的时候，只要key一样，得到的index就一样，这必须要保证。上面三步可以。

取key的hashCode值、高位运算、取模运算。

另外，这三步是分散的，

6. jdk1.8对于循环的优化

JDK1.8后，除了对hashmap增加红黑树结果外，对原有造成死锁的关键原因点（新table复制在头端添加元素）改进为依次在末端添加新的元素。虽然JDK1.8后添加红黑树改进了链表过长查询遍历慢问题和resize时出现导致put死循环的bug，但还是非线性安全的，比如数据丢失等等。因此多线程情况下还是建议使用concurrenthashmap。

java8的resize方法：

主要分为两部分，一部分是扩容，就是把map里面的table的length（threshold）调大，一般情况下变为2倍；然后是复制。将原来的table复制过去。这里，

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
// kaikai: 如果原来数组的j下面不是空，则需要复制。
                    oldTab[j] = null;
                    if (e.next == null)
// kaikai: 如果e只有一个值，直接赋值。
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
// kaikai: 如果e是树，按照树的来。
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
// kaikai: 如果是个链表，一般需要拆分为两个链表；因为size扩充一倍，那么原来在某个位置的node要么还在这个位置，要么迁移到+oldCab的地方；所以需要两个数组；这里使用head和tail表示顺序，来防止jdk8之前的扩容时因为顺序倒过来而引起的环；这里还有一个有趣的地方，就是判断这个node是不动，还是+oldCab，使用(e.hash & oldCap) == 0，要知道oldCab是2的n次方，也就是只有某个位置是1，那么取并为0只有e.hash所有的1（只关心低位）都在低位，如果这个位置hash也是1，那么意味着这个可以放到新的位置了。还记得查找位置的方法吗： e.hash&(oldCab-1)

                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

7.哈希桶数组（Node[] table）

map内部是一个Node数组，叫table，默认大小16；Node继承了Map.Entry。而红黑树节点TreeNode则是LinkedHashMap.Entry。

Node的数组table解释了为什么最快的map的遍历方式是set<entry>，因为只需要遍历一次，HashMap里面是有一个字段，entrySet的。所以查找只需要遍历一次。但是如果是ketSet，那么得到keySet的时候就是一次了。

另外，table里面为什么可以放TreeNode?

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {



    static class Entry<K,V> extends HashMap.Node<K,V> {

里面的ConcurrentProgram子工程，com.kaikai.java.concurrent.hashmap

kaikai7654321

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java之HashMap

多线程成环 void transfer(Entry[] newTable){ Entry[] src = table; int newCapacity = newTable.length; //下面这段代码的意思是： // 从OldTable里摘一个元素出来，然后放到NewTable中 for (int j = 0; j &lt; src.length; j++){Entry&l...
复制链接

扫一扫