一、HashMap介绍
1、确定hash桶的数组索引位置
- 对key取hash：
(key == null) ? 0: (h = key.hashCode()) ^ (h >>> 16);
- 然后计算在hash桶数组中的确定位置：
h & (length-1);上图中的n指的就是hash桶数组的长度
2、HashMap的put方法
按照如下代码块，可以总结出上图的执行流程
- 先判断hash桶数组是否为null，若为空，则进行扩容--1
- 然后计算key要存放在哪个桶中--2
- 若当前table[i] == null，直接插入
- 若不为null，则判断key的hash是不是要相等，若相等，直接覆盖
- 若不为null，且hash不相等，判断是不是树节点，若是树节点，则进行红黑树的插入操作
- 若不为null，且hash不相等，判断不是树节点，则进行链表遍历，并进行计数，若链表遍历到尾部，则插入新的节点，同时判断是不是触发了链表到红黑树的准换，是的话，则进行转换
- 记录map的结构变换次数
- 判断当前size是不是超过了域值，若超过了域值，则进行扩容操作
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}3、扩容操作
扩容操作涉及了将原来的节点搬移到新建立的table[]数组中，jdk1.7代码如下
void transfer(Entry[] newTable) {
Entry[] src = table; //src引用了旧的Entry数组
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组
Entry<K,V> e = src[j]; //取得旧Entry数组的每个元素
if (e != null) {
src[j] = null;//释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象）
do {
Entry<K,V> next = e.next;
int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置
e.next = newTable[i]; //标记[1]
newTable[i] = e; //将元素放在数组上
e = next; //访问下一个Entry链上的元素
} while (e != null);
}
}
}jdk1.8如下
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) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
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;
}4、HashMap的remove操作
5、HashMap的注意事项
(1) 扩容是一个特别耗性能的操作，所以当程序员在使用HashMap的时候，估算map的大小，初始化的时候给一个大致的数值，避免map进行频繁的扩容。
(2) 负载因子是可以修改的，也可以大于1，但是建议不要轻易修改，除非情况非常特殊。
(3) HashMap是线程不安全的，不要在并发的环境中同时操作HashMap，建议使用ConcurrentHashMap。
(4) JDK1.8引入红黑树大程度优化了HashMap的性能。
两者区别
1、二者的存储结构和解决冲突的方法都是相同的（jdk1.7前），jdk1.8以后HashMap在链表结构达到一定长度后，会转换成红黑树，降低时间复杂度，并且在resize（）方法中，发现新的桶位置只是原来位置或者原来位置+原来数组的长度，不需要再计算hash值
2、HashTable在不指定容量的情况下的默认容量为11，而HashMap为16，Hashtable不要求底层数组的容量一定要为2的整数次幂，而HashMap的扩容都是原来table length的2倍
3、Hashtable不允许key和value为空，编译时不会报错，但是运行时会抛出NullPointerException，而HashMap允许key和value为空。
4、Hashtable是线程安全的，而HashMap不是线程安全的
参考博客：https://blog.csdn.net/ns_code/article/details/36034955
synchronized和volatile的区别
一、synchronized分析
1、使用的位置——能够修饰什么
- 修饰实例方法：当前实例方法所在的类对象加锁，进入同步代码块之前要获取该实例对象的锁
- 修饰类方法（静态方法）：当前类的class实例对象加锁，进入同步代码块之前要取得该类的class实例对象的锁
- 修饰代码块：需要指定加锁对象，需要获得指定对象的锁，才能进入同步代码块
2、有什么作用
- 原子性：线程之间互斥执行同步代码块
- 可见性：锁住的对象是线程可见的
- 有序性：释放锁发生在加锁之前
3、是可重入锁
4、同步原理
- 是通过加锁对象所关联的Monitor对象来实现的，该对象是由ObjectMonitor实现的，synchronized的互斥是通过MonitorEnter（代码块的入口）指令和MonitorExit（异常和代码块结束处）两条指令来实现的，这两条指令的实现是依赖操作系统的互斥锁实现
- 当线程运行到MonitorEnter指令时，则去获取Monitor对象，修改锁对象的Mark Work，其中记录了Monitor对象的起始位置
- 其它线程进入未获得该锁，则进入 _EntryList队列，该队列的线程等待获取同步锁
- 若有锁的线程被wait()，则进入_WaitSet 队列，该队列的线程释放锁，并等待被唤醒，唤醒后进入 _EntryList队列
上述这张图有误，应该是4号门得先进入入口区，应为被唤醒后，不一定马上获取到锁，还是得跟入口区的线程进行竞争，上图意思的描述为：
如上图所示，一个线程通过1号门进入Entry Set(入口区)，如果在入口区没有线程等待，那么这个线程就会获取监视器成为监视器的Owner，然后执行监视区域的代码。如果在入口区中有其它线程在等待，那么新来的线程也会和这些线程一起等待。线程在持有监视器的过程中，有两个选择，一个是正常执行监视器区域的代码，释放监视器，通过5号门退出监视器；还有可能等待某个条件的出现，于是它会通过3号门到Wait Set（等待区）休息，直到相应的条件满足后再通过4号门进入重新获取监视器再执行。
5、synchronized和volatile的区别
- volatile不保证互斥，而synchronized可以
- volatile修饰的是变量，而synchronized修饰的是方法和代码块（方法中的代码块），不能单独修饰代码块，修饰变量和类
- volatile不会导致死锁，而synchronized会导致死锁
- synchronized比volatile更消耗资源，数据可见性的方式不一致
- volatile无编译优化，而synchronized有编译优化
二、volatile介绍
1、volatile修饰范围
- 变量
2、volatile的作用
- 保证变量的可见性
- 禁止指令重排序
3、可见性的实现原理
- volatile变量修饰的共享变量，在每次使用的时候，都会从主内存中获取新的值。
- #在进行写操作的时候会多出一个lock前缀的汇编指令，这个指令会触发总线锁或者缓存锁，通过缓存一致性协议来解决可见性问题。（该条有所疑问）
4、如何实现禁止指令重排序
- 通过内存屏障来实现的：重排序不能把后面的指令重排序到内存屏障之前的位置
5、volatile为什么不能保证原子性
- 对volatile变量的操作在jvm层面是需要执行很多步的，而volatile只是保证了读取的时候是最新的，可能写回内存的时候，覆盖了已经修改了最新值
扫一扫
222
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
