-
多线程成环
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> {
8.相关练习代码:
https://github.com/kaikai7654321/JavaStudy
里面的ConcurrentProgram子工程,com.kaikai.java.concurrent.hashmap