map基操，hashmap与hashtable，concurrenthashmap和hashtable，hashmap和treemap,concurrentHashmap是如何实现线程安全的

最新推荐文章于 2024-06-12 21:11:58 发布

code_feien

最新推荐文章于 2024-06-12 21:11:58 发布

阅读量263

点赞数

文章标签： java

本文链接：https://blog.csdn.net/code_feien/article/details/105527606

版权

java 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

map基操，hashmap与hashtable，concurrenthashmap和hashtable，hashmap和treemap,concurrentHashmap是如何实现线程安全的

map基本操作，hashmap与hashtable区别，hashmap需要注意的点
concurrenthashmap和hashtable区别
concurrentHashmap是如何实现线程安全的
转载，hashmap，linkedmap，treemap一些总结
hashmap和treemap区别

map基本操作，hashmap与hashtable区别，hashmap需要注意的点

  map存储的是k-v键值对映射的数据
       实现子类：
           HashMap：数组+链表（1.7） 数组+链表+红黑树（1.8）
           LinkedHashMap：链表
           TreeMap:红黑树
       基本api操作：
           增加：
               put（k,v）    添加元素
           查找：
               isEmpty      判断是否为空
               size        返回map的大小
               containsKey
               containsValue
               get
           删除：
               clear 清空集合中的所有元素
               remove:删除指定元素
               
      Map.entry:表示的是K-V组合的一组映射关系，key和value成组出现
      
      hashmap跟hashtable的区别：
       1、hashmap线程不安全，效率比较高，hashtable线程安全，效率低
       2、hashmap中key和value都可以为null，（只允许一个key为null）,hashtable不允许为空
       
       hashmap中需要注意点：
       a:为什么hashmap初始值为2的N次幂，
           1、2的N次幂减1的二进制为...11111，这样在进行hash（key）操作的时候，可以把
           取余运算转换成与运算，&要比取模运算效率要高
           hash & (initCapacity-1)
           2、在扩容之后涉及到元素的迁移过程，如果hashmap初始值为2的N次幂，迁移的
           时候只需要判断原key值得二进制的前一位是0或者是1即可（比如第一次扩容，本
           来只看后四位，因为16-1=15的二进制是01111，扩容是乘2，即左移一位，所以要
           看11111，后四位还是1，所以只需要看原本key值二进制的倒数第5位是0是1即可）
               如果是0，表示新数组和就数组的下标位置不变，如果是1，只需要将索引位置加上旧的数组的长度值即为新数组的下标
       b: 如果在hashmap同一位置有8个Node，为了提高查询效率，在7个的时候就开始讲这条链表转化为红黑树
       c：扩容操作是table.length*2，左移一位
       d: hashmap在构造函数中没有申请地址空间，在put函数中才申请了地址空间。
       e：扩容后元素迁移时，同一个位置的顺序会反过来（头插法）
       f: 扰动函数：return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);使计算哈希
       值得时候包含了低16位和高16位的特征，从而使哈希值更加不确定来减少碰撞的频率
       g:HashMap默认初始容量为16，负载因子loadFactor为0.75，也就是说只能存储12个元素，当put第13个元素时就需要resize数组将容量扩充到32。
       h:简单翻译一下就是在理想情况下,使用随机哈希码,节点出现的频率在hash桶中遵循泊松分布，同时给出了桶中元素个数和概率的对照表。当桶中元素到达8个的时候，概率已经变得非常小，也就是说用0.75作为加载因子，每个碰撞位置的链表长度超过８个是几乎不可能的。
       i:static class Node<K,V> implements Map.Entry<K,V> {
			  final int hash;
			  final K key;
  			volatile V val;
 			 volatile Node<K,V> next;
 			 ...
			}
			value和next指针使用了volatile来保证其可见性

concurrenthashmap和hashtable区别

concurrenthashmap的内部实现和hashmap大部分操作是相同的，例如：

初始化【默认大小16，2的n次幂，这样hash（key）操作的时候，可以把取余运算转换成与运算，&要比取模运算效率要高，hashcode & (initCapacity-1)】，
扩容【扩容因子默认0.75：简单翻译一下就是在理想情况下,使用随机哈希码,节点出现的频率在hash桶中遵循泊松分布，同时给出了桶中元素个数和概率的对照表。当桶中元素到达8个的时候，概率已经变得非常小，也就是说用0.75作为加载因子，每个碰撞位置的链表长度超过８个是几乎不可能的。
】
链表向红黑树的转变【如果在hashmap同一位置有8个Node，为了提高查询效率，在7个的时候就开始讲这条链表转化为红黑树】等。

ConcurrentHashmap大量使用了CAS方法，大大降低锁带来的性能消耗。在ConcurrentHashMap中还定义了三个原子操作，用于对指定位置的节点进行操作。这三种原子操作被广泛地使用在ConcurrentHashMap的get和put等方法中。

// 获取tab数组的第i个node
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
    return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
// 利用CAS算法设置i位置上的node节点。在CAS中，会比较内存中的值与你指定的这个值是否相等，如果相等才接受
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                    Node<K,V> c, Node<K,V> v) {
    return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
// 利用volatile方法设置第i个节点的值，这个操作一定是成功的。
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
    U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}

JDK8中ConcurrentHashMap的实现使用的是锁分离思想，只是锁住的是一个node，而锁住Node之前的操作是基于在volatile和CAS之上无锁并且线程安全的。

concurrentHashmap是如何实现线程安全的

–init–：在put函数中会进行init操作，这里可能存在线程安全问题，即多个线程对同一个map同时进行初始化。因此ConcurrentHashMap在进行初始化数组的时候使用了乐观锁CAS操作来决定到底哪个线程有资格进行初始化，其他线程只能等待，主要使用的方法有：

volatile变量（sizeCtl）：它是一个标记位，用来告诉其他线程这个坑位有没有人在，其线程间的可见性由volatile保证。
CAS操作：CAS操作保证了设置sizeCtl标记位的原子性，保证了只有一个线程能设置成功。

–put–：该容器减小了锁的粒度，若Hash完美不冲突的情况下，可以同时支持n个线程同时put操作，n为Node数组大小，在默认大小16下，可以支持最大同时16个线程无竞争同时操作且线程安全。当hash冲突严重时，Node链表越来越长，将导致严重的锁竞争，此时会进行扩容，将Node进行再散列，下面会介绍扩容的线程安全性。总结一下用到的并发技巧：

减小锁粒度：将Node链表的头结点作为锁，若在默认大小16的情况下，将有16把锁，大大减小了锁金正，这样可以将串行的部分大大缩小，在理想情况下，线程的put操作都为并行操作。同时直接锁住头结点，保证了线程安全。
Unsafe的getObjectVolatile方法：此方法确保获取到的值是最新的。

–扩容–：在扩容时，ConcurrentHashMap支持多线程并发扩容，在扩容过程中同时支持get查数据，若有线程put数据，还会帮助一起扩容，这种无阻塞算法，将并行最大化的设计，堪称一绝。

在进行迁移时要分低位Node和高位Node，低位Node链表放入原下标处，高位Node则需要加上原Node数组的长度。这样就可以保证高位Node在迁移到新的Node数组中依然可以使用hash算法散列到对应的下标的数组中了。
最后将原Node数组中对应下标Node对象设置为fwd标记Node，表示该节点迁移完成，到这里，一个节点的迁移就完成了，将进行下一个节点的迁移。
迁移过程中的get操作：在get操作的源码中，会判断Node中的hash是否小于0，是否还记得我们的占位Node，其hash为MOVED，为常量值-1，所以此时判断线程正在迁移，委托给fwd占位Node去查找值，

总结：ConcurrentHashMap运用各类CAS操作，将扩容操作的并发性能实现最大化，在扩容过程中，就算有线程调用get查询方法，也可以安全的查询数据，若有线程进行put操作，还会协助扩容，利用sizeCtl标记位和各种volatile变量进行CAS操作达到多线程之间的通信、协助，在迁移过程中只锁一个Node节点，即保证了线程安全，又提高了并发性能。

转载，hashmap，linkedmap，treemap一些总结

一些转自https://www.jianshu.com/p/57d3497ca720的总结

Map主要用于存储健值对，根据键得到值，因此不允许键重复(重复会覆盖)，但允许值重复。

HashMap

Hashmap是一个最常用的Map，它根据键的HashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度。遍历时，取得数据的顺序是完全随机的；

HashMap最多只允许一条记录的键为Null；允许多条记录的值为Null；

HashMap不支持线程的同步（非线程安全），即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致；

同步，可以用Collections的synchronizedMap方法使HashMap具有同步的能力，或者使用ConcurrentHashMap。

在Map中插入、删除和定位元素，HashMap是最好的选择。

AbstractMap抽象类，(HashMap继承AbstractMap)覆盖了equals()和hashCode()方法以确保两个相等映射返回相同的哈希码。如果两个映射大小相等、包含同样的键且每个键在这两个映射中对应的值都相同，则这两个映射相等。

HashMap()：构建一个空的哈希映像

HashMap(Map m)：构建一个哈希映像，并且添加映像m的所有映射

HashMap(int initialCapacity)：构建一个拥有特定容量的空的哈希映像

HashMap(int initialCapacity, float loadFactor)：构建一个拥有特定容量和加载因子的空的哈希映像

HashTable

HashTable与HashMap类似，它不允许记录的键或者值为空；

支持线程的同步（线程安全），即任一时刻只有一个线程能写HashTable，因此导致了Hashtable在写入时会比较慢。

LinkedHashMap

LinkedHashMap是HashMap的一个子类；

LinkedHashMap保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的；

在遍历的时候会比HashMap慢，不过有种情况例外，当HashMap容量很大，实际数据较少时，遍历起来可能会比LinkedHashMap慢，因为LinkedHashMap的遍历速度只和实际数据有关，和容量无关，而HashMap的遍历速度和他的容量有关。

TreeMap

TreeMap实现SortMap接口，能够把它保存的记录根据键排序，默认是按键值的升序排序，也可以指定排序的比较器。当用Iterator遍历TreeMap时，得到的记录是排过序的。

TreeMap取出来的是排序后的键值对。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。

TreeMap基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。

非线程安全

TreeMap()：构建一个空的映像树

TreeMap(Map m)：构建一个映像树，并且添加映像m中所有元素

TreeMap(Comparator c)：构建一个映像树，并且使用特定的比较器对关键字进行排序

TreeMap(SortedMap s)：构建一个映像树，添加映像树s中所有映射，并且使用与有序映像s相同的比较器排序

总结及注意

HashSet是通过HashMap实现的，TreeSet是通过TreeMap实现的，只不过Set用的只是Map的key；

Map的key和Set都有一个共同的特性就是集合的唯一性。TreeMap更是多了一个排序的功能。

hashCode和equal()，HashMap因为无需排序所以只需要关注定位和唯一性即可。

hashCode是用来计算hash值的，hash值是用来确定hash表索引的；

hash表中的一个索引处存放的是一张链表，所以还要通过equal方法循环比较链上的每一个对象才可以真正定位到键值对应的Entry；

put时，如果hash表中没定位到，就在链表前加一个Entry；如果定位到了，则更换Entry中的value，并返回旧value。

由于TreeMap需要排序，所以需要一个Comparator为键值进行大小比较。当然也是用Comparator定位的。

Comparator可以在创建TreeMap时指定；

如果创建时没有确定，那么就会使用key.compareTo()方法，这就要求key必须实现Comparable接口；

TreeMap是使用Tree数据结构实现的，所以使用compare接口就可以完成定位。

Collection没有get()方法来取得某个元素，只能通过iterator()遍历元素。

一般使用ArrayList，用LinkedList构造堆栈stack、队列queue。

LinkedList是由列表实现的List。对顺序访问进行了优化，向List中间插入与删除得开销不大，随机访问则相对较慢(可用ArrayList代替)。它具有方法addFirst()、addLast()、getFirst()、getLast()、removeFirst()、removeLast()，这些方法(没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。

Map中元素，可以将key序列、value序列单独抽取出来。

使用keySet()抽取key序列，将map中的所有keys生成一个Set。

使用values()抽取value序列，将map中的所有values生成一个Collection。

hashmap和treemap区别

Map：在数组中是通过数组下标来对其内容进行索引的，而Map是通过对象来对对象进行索引的，用来索引的对象叫键key，其对应的对象叫值value；

1、HashMap是通过hashcode()对其内容进行快速查找的；HashMap中的元素是没有顺序的；

TreeMap中所有的元素都是有某一固定顺序的，如果需要得到一个有序的结果，就应该使用TreeMap；

2、HashMap和TreeMap都不是线程安全的；

3、HashMap继承AbstractMap类；覆盖了hashcode() 和equals() 方法，以确保两个相等的映射返回相同的哈希值；

 TreeMap继承SortedMap类；他保持键的有序顺序；

4、HashMap：基于hash表实现的；使用HashMap要求添加的键类明确定义了hashcode() 和equals() （可以重写该方法）；为了优化HashMap的空间使用，可以调优初始容量和负载因子；

 TreeMap：基于红黑树实现的；TreeMap就没有调优选项，因为红黑树总是处于平衡的状态；

5、HashMap：适用于Map插入，删除，定位元素；

 TreeMap：适用于按自然顺序或自定义顺序遍历键（key）；

code_feien

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
map基操，hashmap与hashtable，concurrenthashmap和hashtable，hashmap和treemap,concurrentHashmap是如何实现线程安全的

mapmap基本操作，hashmap与hashtable区别，hashmap需要注意的点转载，hashmap，linkedmap，treemap一些总结hashmap和treemap区别map基本操作，hashmap与hashtable区别，hashmap需要注意的点 map存储的是k-v键值对映射的数据实现子类： HashMap：数据+链表（1.7） ...
复制链接

扫一扫