精华内容
下载资源
问答
  • 1.TreeSet,基于TreeMap线程不安全的红黑树数据结构。在线程不安全访问时,有可能出现死循环。 ... android p里面RunningTasks.java...

    1.TreeSet,基于TreeMap线程不安全的红黑树数据结构。在线程不安全访问时,有可能出现死循环。

    https://ivoanjo.me/blog/2018/07/21/writing-to-a-java-treemap-concurrently-can-lead-to-an-infinite-loop-during-reads/

    android p里面RunningTasks.java里面使用的TreeSet 就会有这种情况。

    可以用Collections的辅助api来加上同步保护,注意要在set interrate的时候还要加上同步。 

        /**
         * Returns a synchronized (thread-safe) sorted set backed by the specified
         * sorted set.  In order to guarantee serial access, it is critical that
         * <strong>all</strong> access to the backing sorted set is accomplished
         * through the returned sorted set (or its views).<p>
         *
         * It is imperative that the user manually synchronize on the returned
         * sorted set when iterating over it or any of its <tt>subSet</tt>,
         * <tt>headSet</tt>, or <tt>tailSet</tt> views.
         * <pre>
         *  SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
         *      ...
         *  synchronized (s) {
         *      Iterator i = s.iterator(); // Must be in the synchronized block
         *      while (i.hasNext())
         *          foo(i.next());
         *  }
         * </pre>
         * or:
         * <pre>
         *  SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
         *  SortedSet s2 = s.headSet(foo);
         *      ...
         *  synchronized (s) {  // Note: s, not s2!!!
         *      Iterator i = s2.iterator(); // Must be in the synchronized block
         *      while (i.hasNext())
         *          foo(i.next());
         *  }
         * </pre>
         * Failure to follow this advice may result in non-deterministic behavior.
         *
         * <p>The returned sorted set will be serializable if the specified
         * sorted set is serializable.
         *
         * @param  <T> the class of the objects in the set
         * @param  s the sorted set to be "wrapped" in a synchronized sorted set.
         * @return a synchronized view of the specified sorted set.
         */
        public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) {
            return new SynchronizedSortedSet<>(s);
        }

     2.ArrayList

    ArrayList考虑到线程安全的话可以直接换用Vector,或者也用Collections的api添加synchronized同步锁。

        /**
         * Returns a synchronized (thread-safe) list backed by the specified
         * list.  In order to guarantee serial access, it is critical that
         * <strong>all</strong> access to the backing list is accomplished
         * through the returned list.<p>
         *
         * It is imperative that the user manually synchronize on the returned
         * list when iterating over it:
         * <pre>
         *  List list = Collections.synchronizedList(new ArrayList());
         *      ...
         *  synchronized (list) {
         *      Iterator i = list.iterator(); // Must be in synchronized block
         *      while (i.hasNext())
         *          foo(i.next());
         *  }
         * </pre>
         * Failure to follow this advice may result in non-deterministic behavior.
         *
         * <p>The returned list will be serializable if the specified list is
         * serializable.
         *
         * @param  <T> the class of the objects in the list
         * @param  list the list to be "wrapped" in a synchronized list.
         * @return a synchronized view of the specified list.
         */
        public static <T> List<T> synchronizedList(List<T> list) {
            return (list instanceof RandomAccess ?
                    new SynchronizedRandomAccessList<>(list) :
                    new SynchronizedList<>(list));
        }

     

    展开全文
  • 一、Map概述我们都知道HashMap是线程不安全的,但是HashMap的使用频率在所有map中确实属于比较高的。因为它可以满足我们大多数的场景了。Map类继承图上面展示了java中Map的继承图,Map是一个接口,我们常用的实现类...

    一、Map概述

    我们都知道HashMap是线程不安全的,但是HashMap的使用频率在所有map中确实属于比较高的。因为它可以满足我们大多数的场景了。

    Map类继承图

    上面展示了java中Map的继承图,Map是一个接口,我们常用的实现类有HashMap、LinkedHashMap、TreeMap,HashTable。HashMap根据key的hashCode值来保存value,需要注意的是,HashMap不保证遍历的顺序和插入的顺序是一致的。HashMap允许有一条记录的key为null,但是对值是否为null不做要求。HashTable类是线程安全的,它使用synchronize来做线程安全,全局只有一把锁,在线程竞争比较激烈的情况下hashtable的效率是比较低下的。因为当一个线程访问hashtable的同步方法时,其他线程再次尝试访问的时候,会进入阻塞或者轮询状态,比如当线程1使用put进行元素添加的时候,线程2不但不能使用put来添加元素,而且不能使用get获取元素。所以,竞争会越来越激烈。相比之下,ConcurrentHashMap使用了分段锁技术来提高了并发度,不在同一段的数据互相不影响,多个线程对多个不同的段的操作是不会相互影响的。每个段使用一把锁。所以在需要线程安全的业务场景下,推荐使用ConcurrentHashMap,而HashTable不建议在新的代码中使用,如果需要线程安全,则使用ConcurrentHashMap,否则使用HashMap就足够了。

    LinkedHashMap属于HashMap的子类,与HashMap的区别在于LinkedHashMap保存了记录插入的顺序。TreeMap实现了SortedMap接口,TreeMap有能力对插入的记录根据key排序,默认按照升序排序,也可以自定义比较强,在使用TreeMap的时候,key应当实现Comparable。

    二、HashMap的实现

    java7和java8在实现HashMap上有所区别,当然java8的效率要更好一些,主要是java8的HashMap在java7的基础上增加了红黑树这种数据结构,使得在桶里面查找数据的复杂度从O(n)降到O(logn),当然还有一些其他的优化,比如resize的优化等。

    介于java8的HashMap较为复杂,本文将基于java7的HashMap实现来说明,主要的实现部分还是一致的,java8的实现上主要是做了一些优化,内容还是没有变化的,依然是线程不安全的。

    HashMap的实现使用了一个数组,每个数组项里面有一个链表的方式来实现,因为HashMap使用key的hashCode来寻找存储位置,不同的key可能具有相同的hashCode,这时候就出现哈希冲突了,也叫做哈希碰撞,为了解决哈希冲突,有开放地址方法,以及链地址方法。HashMap的实现上选取了链地址方法,也就是将哈希值一样的entry保存在同一个数组项里面,可以把一个数组项当做一个桶,桶里面装的entry的key的hashCode是一样的。

    HashMap的结构模型(java8)

    上面的图片展示了我们的描述,其中有一个非常重要的数据结构Node,这就是实际保存我们的key-value对的数据结构,下面是这个数据结构的主要内容:

    final int hash;

    final K key;

    V value;

    Node next;

    一个Node就是一个链表节点,也就是我们插入的一条记录,明白了HashMap使用链地址方法来解决哈希冲突之后,我们就不难理解上面的数据结构,hash字段用来定位桶的索引位置,key和value就是我们的数据内容,需要注意的是,我们的key是final的,也就是不允许更改,这也好理解,因为HashMap使用key的hashCode来寻找桶的索引位置,一旦key被改变了,那么key的hashCode很可能就会改变了,所以随意改变key会使得我们丢失记录(无法找到记录)。next字段指向链表的下一个节点。

    HashMap的初始桶的数量为16,loadFact为0.75,当桶里面的数据记录超过阈值的时候,HashMap将会进行扩容则操作,每次都会变为原来大小的2倍,直到设定的最大值之后就无法再resize了。

    下面对HashMap的实现做简单的介绍,具体实现还得看代码,对于java8中的HashMap实现,还需要能理解红黑树这种数据结构。

    1、根据key的hashCode来决定应该将该记录放在哪个桶里面,无论是插入、查找还是删除,这都是第一步,计算桶的位置。因为HashMap的length总是2的n次幂,所以可以使用下面的方法来做模运算:

    h&(length-1)

    h是key的hashCode值,计算好hashCode之后,使用上面的方法来对桶的数量取模,将这个数据记录落到某一个桶里面。当然取模是java7中的做法,java8进行了优化,做得更加巧妙,因为我们的length总是2的n次幂,所以在一次resize之后,当前位置的记录要么保持当前位置不变,要么就向前移动length就可以了。所以java8中的HashMap的resize不需要重新计算hashCode。我们可以通过观察java7中的计算方法来抽象出算法,然后进行优化,具体的细节看代码就可以了。

    2、HashMap的put方法

    HashMap的put方法处理逻辑(java8)

    上图展示了java8中put方法的处理逻辑,比java7多了红黑树部分,以及在一些细节上的优化,put逻辑和java7中是一致的。

    3、resize机制

    HashMap的扩容机制就是重新申请一个容量是当前的2倍的桶数组,然后将原先的记录逐个重新映射到新的桶里面,然后将原先的桶逐个置为null使得引用失效。后面会讲到,HashMap之所以线程不安全,就是resize这里出的问题。

    三、为什么HashMap线程不安全

    上面说到,HashMap会进行resize操作,在resize操作的时候会造成线程不安全。下面将举两个可能出现线程不安全的地方。

    1、put的时候导致的多线程数据不一致。

    这个问题比较好想象,比如有两个线程A和B,首先A希望插入一个key-value对到HashMap中,首先计算记录所要落到的桶的索引坐标,然后获取到该桶里面的链表头结点,此时线程A的时间片用完了,而此时线程B被调度得以执行,和线程A一样执行,只不过线程B成功将记录插到了桶里面,假设线程A插入的记录计算出来的桶索引和线程B要插入的记录计算出来的桶索引是一样的,那么当线程B成功插入之后,线程A再次被调度运行时,它依然持有过期的链表头但是它对此一无所知,以至于它认为它应该这样做,如此一来就覆盖了线程B插入的记录,这样线程B插入的记录就凭空消失了,造成了数据不一致的行为。2、另外一个比较明显的线程不安全的问题是HashMap的get操作可能因为resize而引起死循环(cpu100%),具体分析如下:

    下面的代码是resize的核心内容:

    void transfer(Entry[] newTable, boolean rehash) {

    int newCapacity = newTable.length;

    for (Entry e : table) {

    while(null != e) {

    Entry 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;

    }

    }

    }

    这个方法的功能是将原来的记录重新计算在新桶的位置,然后迁移过去。

    多线程HashMap的resize

    edb543458d9948742abb5bef4e497095.png

    我们假设有两个线程同时需要执行resize操作,我们原来的桶数量为2,记录数为3,需要resize桶到4,原来的记录分别为:[3,A],[7,B],[5,C],在原来的map里面,我们发现这三个entry都落到了第二个桶里面。

    假设线程thread1执行到了transfer方法的Entry next = e.next这一句,然后时间片用完了,此时的e = [3,A], next = [7,B]。线程thread2被调度执行并且顺利完成了resize操作,需要注意的是,此时的[7,B]的next为[3,A]。此时线程thread1重新被调度运行,此时的thread1持有的引用是已经被thread2 resize之后的结果。线程thread1首先将[3,A]迁移到新的数组上,然后再处理[7,B],而[7,B]被链接到了[3,A]的后面,处理完[7,B]之后,就需要处理[7,B]的next了啊,而通过thread2的resize之后,[7,B]的next变为了[3,A],此时,[3,A]和[7,B]形成了环形链表,在get的时候,如果get的key的桶索引和[3,A]和[7,B]一样,那么就会陷入死循环。如果在取链表的时候从头开始取(现在是从尾部开始取)的话,则可以保证节点之间的顺序,那样就不存在这样的问题了。

    综合上面两点,可以说明HashMap是线程不安全的。

    参考链接:https://www.jianshu.com/p/e2f75c8cce01

    展开全文
  • 一、Map概述我们都知道HashMap是线程不安全的,但是HashMap的使用频率在所有map中确实属于比较高的。因为它可以满足我们大多数的场景了。Map类继承图上面展示了java中Map的继承图,Map是一个接口,我们常用的实现类...

    一、Map概述
    我们都知道HashMap是线程不安全的,但是HashMap的使用频率在所有map中确实属于比较高的。因为它可以满足我们大多数的场景了。

    3bc5e1d835691d2ab0b2aa286d428dc4.png


    Map类继承图
    上面展示了java中Map的继承图,Map是一个接口,我们常用的实现类有HashMap、LinkedHashMap、TreeMap,HashTable。HashMap根据key的hashCode值来保存value,需要注意的是,HashMap不保证遍历的顺序和插入的顺序是一致的。HashMap允许有一条记录的key为null,但是对值是否为null不做要求。HashTable类是线程安全的,它使用synchronize来做线程安全,全局只有一把锁,在线程竞争比较激烈的情况下hashtable的效率是比较低下的。因为当一个线程访问hashtable的同步方法时,其他线程再次尝试访问的时候,会进入阻塞或者轮询状态,比如当线程1使用put进行元素添加的时候,线程2不但不能使用put来添加元素,而且不能使用get获取元素。所以,竞争会越来越激烈。相比之下,ConcurrentHashMap使用了分段锁技术来提高了并发度,不在同一段的数据互相不影响,多个线程对多个不同的段的操作是不会相互影响的。每个段使用一把锁。所以在需要线程安全的业务场景下,推荐使用ConcurrentHashMap,而HashTable不建议在新的代码中使用,如果需要线程安全,则使用ConcurrentHashMap,否则使用HashMap就足够了。
    LinkedHashMap属于HashMap的子类,与HashMap的区别在于LinkedHashMap保存了记录插入的顺序。TreeMap实现了SortedMap接口,TreeMap有能力对插入的记录根据key排序,默认按照升序排序,也可以自定义比较强,在使用TreeMap的时候,key应当实现Comparable。
    二、HashMap的实现
    java7和java8在实现HashMap上有所区别,当然java8的效率要更好一些,主要是java8的HashMap在java7的基础上增加了红黑树这种数据结构,使得在桶里面查找数据的复杂度从O(n)降到O(logn),当然还有一些其他的优化,比如resize的优化等。
    介于java8的HashMap较为复杂,本文将基于java7的HashMap实现来说明,主要的实现部分还是一致的,java8的实现上主要是做了一些优化,内容还是没有变化的,依然是线程不安全的。
    HashMap的实现使用了一个数组,每个数组项里面有一个链表的方式来实现,因为HashMap使用key的hashCode来寻找存储位置,不同的key可能具有相同的hashCode,这时候就出现哈希冲突了,也叫做哈希碰撞,为了解决哈希冲突,有开放地址方法,以及链地址方法。HashMap的实现上选取了链地址方法,也就是将哈希值一样的entry保存在同一个数组项里面,可以把一个数组项当做一个桶,桶里面装的entry的key的hashCode是一样的。

    946f40037ad18fdcaad08fc29b9f6e87.png


    HashMap的结构模型(java8)
    上面的图片展示了我们的描述,其中有一个非常重要的数据结构Node<K,V>,这就是实际保存我们的key-value对的数据结构,下面是这个数据结构的主要内容:
    final int hash; final K key; V value; Node<K,V> next;
    一个Node就是一个链表节点,也就是我们插入的一条记录,明白了HashMap使用链地址方法来解决哈希冲突之后,我们就不难理解上面的数据结构,hash字段用来定位桶的索引位置,key和value就是我们的数据内容,需要注意的是,我们的key是final的,也就是不允许更改,这也好理解,因为HashMap使用key的hashCode来寻找桶的索引位置,一旦key被改变了,那么key的hashCode很可能就会改变了,所以随意改变key会使得我们丢失记录(无法找到记录)。next字段指向链表的下一个节点。
    HashMap的初始桶的数量为16,loadFact为0.75,当桶里面的数据记录超过阈值的时候,HashMap将会进行扩容则操作,每次都会变为原来大小的2倍,直到设定的最大值之后就无法再resize了。
    下面对HashMap的实现做简单的介绍,具体实现还得看代码,对于java8中的HashMap实现,还需要能理解红黑树这种数据结构。
    1、根据key的hashCode来决定应该将该记录放在哪个桶里面,无论是插入、查找还是删除,这都是第一步,计算桶的位置。因为HashMap的length总是2的n次幂,所以可以使用下面的方法来做模运算:
    h&(length-1)
    h是key的hashCode值,计算好hashCode之后,使用上面的方法来对桶的数量取模,将这个数据记录落到某一个桶里面。当然取模是java7中的做法,java8进行了优化,做得更加巧妙,因为我们的length总是2的n次幂,所以在一次resize之后,当前位置的记录要么保持当前位置不变,要么就向前移动length就可以了。所以java8中的HashMap的resize不需要重新计算hashCode。我们可以通过观察java7中的计算方法来抽象出算法,然后进行优化,具体的细节看代码就可以了。
    2、HashMap的put方法

    13c9b658ead905977dff536e7cd5ae36.png


    HashMap的put方法处理逻辑(java8)
    上图展示了java8中put方法的处理逻辑,比java7多了红黑树部分,以及在一些细节上的优化,put逻辑和java7中是一致的。
    3、resize机制
    HashMap的扩容机制就是重新申请一个容量是当前的2倍的桶数组,然后将原先的记录逐个重新映射到新的桶里面,然后将原先的桶逐个置为null使得引用失效。后面会讲到,HashMap之所以线程不安全,就是resize这里出的问题。
    三、为什么HashMap线程不安全
    上面说到,HashMap会进行resize操作,在resize操作的时候会造成线程不安全。下面将举两个可能出现线程不安全的地方。
    1、put的时候导致的多线程数据不一致。
    这个问题比较好想象,比如有两个线程A和B,首先A希望插入一个key-value对到HashMap中,首先计算记录所要落到的桶的索引坐标,然后获取到该桶里面的链表头结点,此时线程A的时间片用完了,而此时线程B被调度得以执行,和线程A一样执行,只不过线程B成功将记录插到了桶里面,假设线程A插入的记录计算出来的桶索引和线程B要插入的记录计算出来的桶索引是一样的,那么当线程B成功插入之后,线程A再次被调度运行时,它依然持有过期的链表头但是它对此一无所知,以至于它认为它应该这样做,如此一来就覆盖了线程B插入的记录,这样线程B插入的记录就凭空消失了,造成了数据不一致的行为。
    2、另外一个比较明显的线程不安全的问题是HashMap的get操作可能因为resize而引起死循环(cpu100%),具体分析如下:
    下面的代码是resize的核心内容:

    54a7889995dbcb1b32ac087f2417540d.png


    这个方法的功能是将原来的记录重新计算在新桶的位置,然后迁移过去。

    548e2ab4a26da2b4f6454b5a3b7a6372.png


    多线程HashMap的resize
    我们假设有两个线程同时需要执行resize操作,我们原来的桶数量为2,记录数为3,需要resize桶到4,原来的记录分别为:[3,A],[7,B],[5,C],在原来的map里面,我们发现这三个entry都落到了第二个桶里面。
    假设线程thread1执行到了transfer方法的Entry next = e.next这一句,然后时间片用完了,此时的e = [3,A], next = [7,B]。线程thread2被调度执行并且顺利完成了resize操作,需要注意的是,此时的[7,B]的next为[3,A]。此时线程thread1重新被调度运行,此时的thread1持有的引用是已经被thread2 resize之后的结果。线程thread1首先将[3,A]迁移到新的数组上,然后再处理[7,B],而[7,B]被链接到了[3,A]的后面,处理完[7,B]之后,就需要处理[7,B]的next了啊,而通过thread2的resize之后,[7,B]的next变为了[3,A],此时,[3,A]和[7,B]形成了环形链表,在get的时候,如果get的key的桶索引和[3,A]和[7,B]一样,那么就会陷入死循环。
    如果在取链表的时候从头开始取(现在是从尾部开始取)的话,则可以保证节点之间的顺序,那样就不存在这样的问题了。
    综合上面两点,可以说明HashMap是线程不安全的。

    展开全文
  • 我们都知道HashMap是线程不安全的,但是HashMap的使用频率在所有map中确实属于比较高的。因为它可以满足我们大多数的场景了。 Map类继承图 上面展示了java中Map的继承图,Map是一个接口,我们常用的实现类有HashMap...

    一、Map概述

    我们都知道HashMap是线程不安全的,但是HashMap的使用频率在所有map中确实属于比较高的。因为它可以满足我们大多数的场景了。
    在这里插入图片描述

    Map类继承图
    上面展示了java中Map的继承图,Map是一个接口,我们常用的实现类有HashMap、LinkedHashMap、TreeMap,HashTable。HashMap根据key的hashCode值来保存value,需要注意的是,HashMap不保证遍历的顺序和插入的顺序是一致的。HashMap允许有一条记录的key为null,但是对值是否为null不做要求。HashTable类是线程安全的,它使用synchronize来做线程安全,全局只有一把锁,在线程竞争比较激烈的情况下hashtable的效率是比较低下的。因为当一个线程访问hashtable的同步方法时,其他线程再次尝试访问的时候,会进入阻塞或者轮询状态,比如当线程1使用put进行元素添加的时候,线程2不但不能使用put来添加元素,而且不能使用get获取元素。所以,竞争会越来越激烈。相比之下,ConcurrentHashMap使用了分段锁技术来提高了并发度,不在同一段的数据互相不影响,多个线程对多个不同的段的操作是不会相互影响的。每个段使用一把锁。所以在需要线程安全的业务场景下,推荐使用ConcurrentHashMap,而HashTable不建议在新的代码中使用,如果需要线程安全,则使用ConcurrentHashMap,否则使用HashMap就足够了。

    LinkedHashMap属于HashMap的子类,与HashMap的区别在于LinkedHashMap保存了记录插入的顺序。TreeMap实现了SortedMap接口,TreeMap有能力对插入的记录根据key排序,默认按照升序排序,也可以自定义比较强,在使用TreeMap的时候,key应当实现Comparable。

    二、HashMap的实现

    java7和java8在实现HashMap上有所区别,当然java8的效率要更好一些,主要是java8的HashMap在java7的基础上增加了红黑树这种数据结构,使得在桶里面查找数据的复杂度从O(n)降到O(logn),当然还有一些其他的优化,比如resize的优化等。
    介于java8的HashMap较为复杂,本文将基于java7的HashMap实现来说明,主要的实现部分还是一致的,java8的实现上主要是做了一些优化,内容还是没有变化的,依然是线程不安全的。
    HashMap的实现使用了一个数组,每个数组项里面有一个链表的方式来实现,因为HashMap使用key的hashCode来寻找存储位置,不同的key可能具有相同的hashCode,这时候就出现哈希冲突了,也叫做哈希碰撞,为了解决哈希冲突,有开放地址方法,以及链地址方法。HashMap的实现上选取了链地址方法,也就是将哈希值一样的entry保存在同一个数组项里面,可以把一个数组项当做一个桶,桶里面装的entry的key的hashCode是一样的。
    HashMap的结构模型(java8)

    上面的图片展示了我们的描述,其中有一个非常重要的数据结构Node<K,V>,这就是实际保存我们的key-value对的数据结构,下面是这个数据结构的主要内容:

    	   final int hash;    
           final K key;
           V value;
           Node<K,V> next;
    

    一个Node就是一个链表节点,也就是我们插入的一条记录,明白了HashMap使用链地址方法来解决哈希冲突之后,我们就不难理解上面的数据结构,hash字段用来定位桶的索引位置,key和value就是我们的数据内容,需要注意的是,我们的key是final的,也就是不允许更改,这也好理解,因为HashMap使用key的hashCode来寻找桶的索引位置,一旦key被改变了,那么key的hashCode很可能就会改变了,所以随意改变key会使得我们丢失记录(无法找到记录)。next字段指向链表的下一个节点。

    HashMap的初始桶的数量为16,loadFact为0.75,当桶里面的数据记录超过阈值的时候,HashMap将会进行扩容则操作,每次都会变为原来大小的2倍,直到设定的最大值之后就无法再resize了。

    下面对HashMap的实现做简单的介绍,具体实现还得看代码,对于java8中的HashMap实现,还需要能理解红黑树这种数据结构。

    1、根据key的hashCode来决定应该将该记录放在哪个桶里面,无论是插入、查找还是删除,这都是第一步,计算桶的位置。因为HashMap的length总是2的n次幂,所以可以使用下面的方法来做模运算:

    h&(length-1)
    

    h是key的hashCode值,计算好hashCode之后,使用上面的方法来对桶的数量取模,将这个数据记录落到某一个桶里面。当然取模是java7中的做法,java8进行了优化,做得更加巧妙,因为我们的length总是2的n次幂,所以在一次resize之后,当前位置的记录要么保持当前位置不变,要么就向前移动length就可以了。所以java8中的HashMap的resize不需要重新计算hashCode。我们可以通过观察java7中的计算方法来抽象出算法,然后进行优化,具体的细节看代码就可以了。

    2、HashMap的put方法
    HashMap的put方法处理逻辑(java8)

    上图展示了java8中put方法的处理逻辑,比java7多了红黑树部分,以及在一些细节上的优化,put逻辑和java7中是一致的。

    3、resize机制

    HashMap的扩容机制就是重新申请一个容量是当前的2倍的桶数组,然后将原先的记录逐个重新映射到新的桶里面,然后将原先的桶逐个置为null使得引用失效。后面会讲到,HashMap之所以线程不安全,就是resize这里出的问题。

    三、为什么HashMap线程不安全

    上面说到,HashMap会进行resize操作,在resize操作的时候会造成线程不安全。下面将举两个可能出现线程不安全的地方。

    1、put的时候导致的多线程数据不一致。
    这个问题比较好想象,比如有两个线程A和B,首先A希望插入一个key-value对到HashMap中,首先计算记录所要落到的桶的索引坐标,然后获取到该桶里面的链表头结点,此时线程A的时间片用完了,而此时线程B被调度得以执行,和线程A一样执行,只不过线程B成功将记录插到了桶里面,假设线程A插入的记录计算出来的桶索引和线程B要插入的记录计算出来的桶索引是一样的,那么当线程B成功插入之后,线程A再次被调度运行时,它依然持有过期的链表头但是它对此一无所知,以至于它认为它应该这样做,如此一来就覆盖了线程B插入的记录,这样线程B插入的记录就凭空消失了,造成了数据不一致的行为。

    2、另外一个比较明显的线程不安全的问题是HashMap的get操作可能因为resize而引起死循环(cpu100%),具体分析如下:

    下面的代码是resize的核心内容:

    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;  
                } 
            }  
        } 
    

    这个方法的功能是将原来的记录重新计算在新桶的位置,然后迁移过去。
    多线程HashMap的resize

    我们假设有两个线程同时需要执行resize操作,我们原来的桶数量为2,记录数为3,需要resize桶到4,原来的记录分别为:[3,A],[7,B],[5,C],在原来的map里面,我们发现这三个entry都落到了第二个桶里面。
    假设线程thread1执行到了transfer方法的Entry next = e.next这一句,然后时间片用完了,此时的e = [3,A], next = [7,B]。线程thread2被调度执行并且顺利完成了resize操作,需要注意的是,此时的[7,B]的next为[3,A]。此时线程thread1重新被调度运行,此时的thread1持有的引用是已经被thread2 resize之后的结果。线程thread1首先将[3,A]迁移到新的数组上,然后再处理[7,B],而[7,B]被链接到了[3,A]的后面,处理完[7,B]之后,就需要处理[7,B]的next了啊,而通过thread2的resize之后,[7,B]的next变为了[3,A],此时,[3,A]和[7,B]形成了环形链表,在get的时候,如果get的key的桶索引和[3,A]和[7,B]一样,那么就会陷入死循环。

    如果在取链表的时候从头开始取(现在是从尾部开始取)的话,则可以保证节点之间的顺序,那样就不存在这样的问题了。

    综合上面两点,可以说明HashMap是线程不安全的。

    展开全文
  • 为什么HashMap是线程不安全的 一、Map概述 我们都知道HashMap是线程不安全的,但是HashMap的使用频率在所有map中确实属于比较高的。因为它可以满足我们大多数的场景了。 Map类继承图 上面展示了java中Map的继承图,...
  • 一、Map概述我们都知道HashMap是线程不安全的,但是HashMap的使用频率在所有map中确实属于比较高的。因为它可以满足我们大多数的场景了。Map类继承图上面展示了java中Map的继承图,Map是一个接口,我们常用的实现类...
  • 我们都知道HashMap是线程不安全的,但是HashMap的使用频率在所有map中确实属于比较高的。因为它可以满足我们大多数的场景了。 Map类继承图 上面展示了java中Map的继承图,Map是一个接口,我们常用的实现类有...
  • 但是线程不安全,线程的安全的话可以使用tableMap,但tableMap的锁太重,因此可以使用ConcurretHashMap采取分段锁的方式性能更搞。 HashMap无序,如果要有序遍历的情况可以使用treeMap。 Concurr...
  • map是广义集合一部分。我是李福春,我在准备面试,今天我们来回答:...线程安全 是否支持null键值 使用场景 HashTable 是 支持 java早期hash实现,同步开销大推荐被使用 HashMap 否 支持 大部分场景的首...
  • HashMap和LinkedHashMap的区别 LinkedHashMap是继承于HashMap,是基于HashMap和双向链表来实现的。 HashMap无序;LinkedHashMap有序,可分为插入顺序和访问顺序两种。...LinkedHashMap是线程不安全的。 使用
  • 我们都知道HashMap是线程不安全的,但是HashMap的使用频率在所有map中确实属于比较高的。因为它可以满足我们大多数的场景了。 Map类继承图 上面展示了java中Map的继承图,Map是一个接口,我们常用的实现类有HashMap...
  • map是广义集合一部分。 我是李福春,我在准备面试,今天我们来回答: ...线程安全 是否支持null键值 使用场景 HashTable 是 支持 java早期hash实现,同步开销大推荐被使用 HashMap 否 支...
  • ConcurrentSkipListMap是线程安全的有序的哈希表,适用于高并发的场景。 ConcurrentSkipListMap和TreeMap,它们虽然都是有序的哈希表。但是,第一,它们的线程安全机制不同,TreeMap是非线程安全的,而...
  • ConcurrentHashMap使用场景

    千次阅读 2018-05-24 10:22:59
    先大概说一下几个map区别:hashMap:读取快,插入慢,线程不安全LinkedHashMap:读取快,插入慢treeMap:排序concurrentHashMap:线程安全,支持高并发操作当项目中全局变量有多线程操作时需要用...
  • 为什么HashMap不安全

    2019-05-15 08:00:55
    我们都知道HashMap是线程不安全的,但是HashMap的使用频率在所有map中确实属于比较高的。因为它可以满足我们大多数的场景了。 Map类继承图 复制代码 Map是一个接口,我们常用的实现类有HashMap、LinkedHashMap、...
  • (1)hashMap: 以键值对尽心存储,线程不安全,无序,可以允许一个null键和多个null,可以通过键直接获取对应值,所以查询效率高 (2) hashtable: 它也是通过键值对进行存储,无序,但是他是线程安全的,绝大多数...
  • 在前面,我们了解到了HashMap使用及原理,HashMap是一种非常常见、非常有用集合,大多数情况下,只要涉及线程安全问题,Map基本都可以使用HashMap。不过HashMap有一个问题,就是迭代HashMap顺序并是...
  • 使用1.8之前使用 位桶和链表实现(1.8改用红黑树),它是线程不安全的Map,方法上都没有synchronize关键字修饰。默认16,多线程下resize,rehash时可能会出现死锁,拖死系统。 TreeMap 他具有一个很大的...
  • Java中的map是一个很重要的集合,他是一个接口,它实现了多个实现类。 map的主要特点是键值对的形式,一一对应,且一个key只对应1个value。 其常用的map实现类主要有...最常用,线程不安全的Map HashTable hashTa...
  • 上述三个Map都不是线程安全的,因此在高并发的时候推荐使用。Set同理,只需要将Map换为Set即可。 并发不是很大时: Hashtable:早期的线程安全Map。速度较慢,高并发下推荐使用。 Collections.sychroni...
  • 概要 本章对Java.util.concurrent包中的...ConcurrentSkipListMap是线程安全的有序的哈希表,适用于高并发的场景。 ConcurrentSkipListMap和TreeMap,它们虽然都是有序的哈希表。但是,第一,它们的线程安全机制...
  • 为什么Collections.synchronizedMap是线程安全的?从源码分析HashMap什么是Hash碰撞?常见的解决办法有哪些?HashMap为什么用数组+链表+红黑树这几类结构呢?为什么选择红黑树而不用其他树,比如二叉查找树,为啥...
  • 在插入元素时容量扩充机制和ArrayList稍有不同: 基于HashMap完成, 允许元素重复。 非线程安全。 基于TreeMap完成, 支持排序。 采用数组方式存储key、value构成Entry对象, 在插入元素时可能会扩展数组...
  • 快手一面(2020-9-19)

    2020-09-20 14:29:21
    hashmap的多线程安全,不安全会发生什么问题 线程安全的hashmap是啥?,是如何保证线程安全 JUC的原子类 AtomicInteger如何实现 CAS的原理 乐观锁和悲观锁是什么,以及应用场景 概率题 两个用long...
  • HashMap重点知识点整理HashMap内部结构1.8 版本有哪些变化HashMap 容量初始化哈希函数实现为什么用异或运算符HashMap 是否线程安全解决线程不安全方法HashMap 和 HashTable 区别ConcurrentHashMap 分段锁...
  • HashMap简介与展开

    2020-04-09 23:02:04
    Map 接口 HashMap 实现Map LinkedHashMap 是HashMap 子类...HashMap 线程不安全——因为resize扩容机制 HashTable线程安全——用synchronize做线程——全局就一把锁——效率低 有线程安全场景要求可使用:Concurre...
  • 一个支持排序链表,java api,网上找半天没有合适,实在困惑(有知道流行类库有类似结构请留言~ ),自己贡献一个。 一般场景下,TreeSet,TreeMap满足大部分业务场景...线程不安全。需要更多feature可以直接更

空空如也

空空如也

1 2
收藏数 38
精华内容 15
关键字:

treemap线程不安全的场景