HashTable , HashMap 以及 ConcurrentHashMap的区别

妖狐艹你老母 2024-03-23 12:25 64阅读 0赞

## HashTable , HashMap 以及 ConcurrentHashMap的区别 ##

![请添加图片描述][b0c2b0923b3b4df7af198b084cec0c60.jpeg]

*  HashTable 和 HashMap
    
     *  首先,HashMap是非同步的, 也就是说, HashMap是线程不安全的,在多线程的场景中,没有锁的保护,很容易出现数据不一致的问题.
        
        HashTable是同步的,所有的读写都进行了锁的保护 , 但是会对读写效率产生比较大的影响.
        
        HashTable的源码put添加方法中,**是直接对方法加synchronized锁(其他方法也是一样的)**
        
            public synchronized V put(K key, V value) {
                    
                // Make sure the value is not null
                if (value == null) {
                    
                    throw new NullPointerException();
                }
            
                // Makes sure the key is not already in the hashtable.
                Entry<?,?> tab[] = table;
                int hash = key.hashCode();
                int index = (hash & 0x7FFFFFFF) % tab.length;
                @SuppressWarnings("unchecked")
                Entry<K,V> entry = (Entry<K,V>)tab[index];
                for(; entry != null ; entry = entry.next) {
                    
                    if ((entry.hash == hash) && entry.key.equals(key)) {
                    
                        V old = entry.value;
                        entry.value = value;
                        return old;
                    }
                }
            
                addEntry(hash, key, value, index);
                return null;
            }
     *  HashMap的结构中, 是允许保存null值的, key 和 value 都是允许存取 null 值的,
        
        但是在 Hashtable中\*\*,HashMap的key - value 是不能够存放null值的 如果值为空 会抛出 `throw new NullPointerException()` 空指针异常\*\*
 *  HashTable 和 ConcurrentHashMap的区别
    
     *  两者都是线程安全的,但是加锁的方式是不同的
        
        首先两者的底层结构都是 数组 + 链表的形式 HashTable 是对方法加锁 也就意味着,在多线程中,只有一个线程能进行添加操作因此效率会非常的低 .\[外链图片转存失败,源站可能有防盗链机制,建议将图片![保存下来直接上传(img-lef9nYmA-1681463824666)(assets/image-20230414170600784.png)\]][img-lef9nYmA-1681463824666_assets_image-20230414170600784.png]  
        但是concurrentHashMap就不是对整个数组加锁, 而是桶加锁 (也就是对每一条链表加锁) 也就是数组的每一个元素进行加锁,**因为每一条链表之间的修改是互不影响的,(因为不在同一个链表上, 因此多个线程修改并不会使数据不一致),从而提高了修改效率,同时也保证了线程的安全.**
        
        ![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MB7yneLd-1681463824667)(assets/image-20230414170928132.png)\]][img-MB7yneLd-1681463824667_assets_image-20230414170928132.png]
        
        查看concurrentHashMap的底层put机制源码:
        
            public V put(K key, V value) {
                    
                return putVal(key, value, false);
            }
            /** 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;
                for (Node<K,V>[] tab = table;;) {
                    
                    Node<K,V> f; int n, i, fh;
                    if (tab == null || (n = tab.length) == 0)
                        tab = initTable();
                    else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                    
                        if (casTabAt(tab, i, null,
                                     new Node<K,V>(hash, key, value, null)))
                            break;                   // no lock when adding to empty bin
                    }
                    else if ((fh = f.hash) == MOVED)
                        tab = helpTransfer(tab, f);
                    else {
                    
                        V oldVal = null;
                        synchronized (f) {
                    
                            if (tabAt(tab, i) == f) {
                    
                                if (fh >= 0) {
                    
                                    binCount = 1;
                                    for (Node<K,V> e = f;; ++binCount) {
                    
                                        K ek;
                                        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;
                                    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;
                        }
                    }
                }
                addCount(1L, binCount);
                return null;
            }
        
        可以看到,put操作并不是直接对方法进行加锁 而是在当要修改值的时候,提供一把锁 判断是否该锁对应的就是该链表,这样就可以保证 一条链表的安全机制.
        
        ![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YT9HalN5-1681463824667)(assets/image-20230414171359005.png)\]][img-YT9HalN5-1681463824667_assets_image-20230414171359005.png]

[b0c2b0923b3b4df7af198b084cec0c60.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/6ab57b8a46d54005bf11ab798153ddd1.png
[img-lef9nYmA-1681463824666_assets_image-20230414170600784.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/990079644dcd48ea8384cdd4a18cda6a.png
[img-MB7yneLd-1681463824667_assets_image-20230414170928132.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/36756bb2a7bc47fabec9a396d6141974.png
[img-YT9HalN5-1681463824667_assets_image-20230414171359005.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/70fd8ea980c94889a6f48738e128702e.png