并发编程学习笔记（三）

小军的编程之旅

已于 2022-07-18 16:31:34 修改

阅读量237

点赞数 1

文章标签：学习 java

于 2022-07-18 16:30:16 首次发布

本文链接：https://blog.csdn.net/xuejun_1996/article/details/125851408

版权

并发List、Set、 ConcurrentHashMap底层原理

java集合框架

ArrayList

在这里插入图片描述

1、特点

List 特点：元素顺序存储，元素可重复
存储结构：底层采用数组来实现

2、Cloneable

支持拷贝：实现Cloneable接口，重写clone方法、方法内容默认调用父类的clone方法。

2.1 浅拷贝

基础类型的变量拷贝之后是独立的，不会随着源变量变动而变。
String类型拷贝之后也是独立的。
引用类型拷贝的是引用地址，拷贝前后的变量引用同一个堆中的对象。

浅拷贝基本类型（int类型）是独立的（改了值会生效），引用类型不独立的（同一份数据，string也是同样的）

2.2 深拷贝

变量的所有引用类型变量（除了String）都需要实现Cloneable（数组可以直接调用clone方法），clone方法中，引用类型需要各自调用clone，重新赋值。

java的传参，基本类型和引用类型传参
java在方法传递参数时，是将变量复制一份，然后传入方法体去执行。复制的是栈中的内容
所以基本类型是复制的变量名和值，值变了不影响源变量
引用类型复制的是变量名和值（引用地址），对象变了，会影响源变量（引用地址是一样的）
String：是不可变对象，重新赋值时，会在常量表新生成字符串（如果已有，直接取他的引用地址），将新字符串的引用地址赋值给栈中的新变量，因此源变量不会受影响.

3、Serializable

序列化：为了网络传输和存盘，将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。

4、基本属性

private static final long serialVersionUID = 8683452581122892189L;//序列化版本号（类文件签名），如果不写会默认生成，类内容的改变会影响签名变化，导致反序列化失败
private static final int DEFAULT_CAPACITY = 10;//如果实例化时未指定容量，则在初次添加元素时会进行扩容使用此容量作为数组长度
//static修饰，所有的未指定容量的实例(也未添加元素)共享此数组，两个空的数组有什么区别呢？ 就是第一次添加元素时知道该 elementData 从空的构造函数还是有参构造函数被初始化的。以便确认如何扩容。空的构造器则初始化为10，有参构造器则按照扩容因子扩容
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData; // arrayList真正存放元素的地方，长度大于等于size
private int size;//arrayList中的元素个数

5、迭代器 iterator

public Iterator<E> iterator() {
    return new Itr();
}
private class Itr implements Iterator<E> {
    int cursor;       // 代表下一个要访问的元素下标
    int lastRet = -1; // 代表上一个要访问的元素下标
    int expectedModCount = modCount;//代表对 ArrayList 修改次数的期望值，初始值为 modCount
    //如果下一个元素的下标等于集合的大小 ，就证明到最后了
    public boolean hasNext() {
        return cursor != size;
    }
    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();//判断expectedModCount和modCount是否相等,ConcurrentModificationException
        int i = cursor;
        if (i >= size)//对 cursor 进行判断，看是否超过集合大小和数组长度
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;//自增 1。开始时，cursor = 0，lastRet = -1；每调用一次next方法，cursor和lastRet都会自增1。
        return (E) elementData[lastRet = i];//将cursor赋值给lastRet，并返回下标为 lastRet 的元素
    }
    public void remove() {
        if (lastRet < 0)//判断 lastRet 的值是否小于 0
            throw new IllegalStateException();
        checkForComodification();//判断expectedModCount和modCount是否相等,ConcurrentModificationException
        try {
            ArrayList.this.remove(lastRet);//直接调用 ArrayList 的 remove 方法删除下标为 lastRet 的元素
            cursor = lastRet;//将 lastRet 赋值给 curso
            lastRet = -1;//将 lastRet 重新赋值为 -1，并将 modCount 重新赋值给 expectedModCount。
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

remove 方法的弊端：

1、只能进行remove操作，add、clear 等 Itr 中没有。
2、调用 remove 之前必须先调用 next。因为 remove 开始就对 lastRet 做了校验。而 lastRet 初始化时为 -1。
3、next 之后只可以调用一次 remove。因为 remove 会将 lastRet 重新初始化为 -1

6、什么是fail-fast？

fail-fast机制是java集合中的一种错误机制。
当使用迭代器迭代时，如果发现集合有修改，则快速失败做出响应，抛出ConcurrentModificationException异常。
这种修改有可能是其它线程的修改，也有可能是当前线程自己的修改导致的，比如迭代的过程中直接调用remove()删除元素等。
另外，并不是java中所有的集合都有fail-fast的机制。比如，像最终一致性的ConcurrentHashMap、CopyOnWriterArrayList等都是没有fast-fail的。
fail-fast是怎么实现的：
ArrayList、HashMap中都有一个属性modcount，每次对集合的修改这个值都会加1，在遍历前记录这个值expert*count中，遍历中检查两者是否一致，如果出现不一致就说明有修改，则抛出ConcurrentModificationException异常。
底层数组存/取元素效率非常的高(get/set)，时间复杂度是O(1)，而查找（比如：indexOf，contain），插入和删除元素效率不太高，时间复杂度为O(n)。
插入/删除元素会触发底层数组频繁拷贝，效率不高，还会造成内存空间的浪费，解决方案：linkedList
查找元素效率不高，解决方案：HashMap（红黑树）

LinkedList：

特性：底层采用链表来实现的。和数组几乎完全相反，数组查询快，复杂度为O(1),插入和删除比较慢，复杂度为O(n); 链表插入和删除比较快，查询比较慢。

HashMap

1、基本特性

1、存储结构：底层采用数组+链表+红黑树实现
2、特点：key、value存储，key可以为null，同样的key会被覆盖掉

2、hash算法

意义：在于提供了一种快速存取数据的方法,它用一种算法建立键值与真实值之间的对应关系。

1、从Hash值不能反向推导出原始数据（所以哈希算法也叫单向哈希算法）；
2、对输入数据非常敏感，哪怕原始数据只修改了一个数据，最后得到的Hash值也大不相同；
3、散列冲突的概率要很小，对于不同的原始数据，Hash值相同的概率非常小；
4、哈希算法的执行效率要尽量高效，针对较长的文本，也能快速地计算出Hash值

应用：

1、安全加密
2、密码储存
3、唯一标识
4、数据校验

原理讲解：

哈希算法（也叫散列），就是把任意长度值(Key)通过散列算法变换成固定长度的key（地址）通过这个地址进行访问的数据结构它通过把关键码值映射到表中一个。位置来访问记录，以加快查找的速度。

在这里插入图片描述
哈希冲突

用链表是来解决数组下标会覆盖的问题，冲突的问题。为什么hashMap 用两个数据结构。两个数据结构。JDK8 红黑树？？？
因为链表查询的时候链表过长了查询效率非常低，所以需要用红黑树。

HashMap中PUT方法的流程
在这里插入图片描述

1. 通过key计算出一个hashcode
2. 通过hashcode与“与操作”计算出一个数组下标 
3. 在把put进来的key,value封装为一个entry对象 
4. 判断数组下标对应的位置，是不是空，如果是空则把entry直接存在该数组位置
5. 如果该下标对应的位置不为空，则需要把entry插入到链表中
6. 并且还需要判断该链表中是否存在相同的key，如果存在，则更新value 
7. 如果是JDK7，则使用头插法 
8. 如果是JDK8，则会遍历链表，并且在遍历链表的过程中，统计当前链表的元素个数，如果超过8个，则先把链表转变为红黑树，并且把元素插入到红黑树中

**jdk7和jdk8关于HashMap的区别：**

1. JDK8中新增了红黑树，JDK8是通过数组+链表+红黑树来实现的
2. JDK7中链表的插入是用的头插法，而JDK8中则改为了尾插法 
3. JDK8中的因为使用了红黑树保证了插入和查询了效率，所以实际上JDK8中的Hash算法实现的复杂度降低了 
4. JDK8中数组扩容的条件也发了变化，只会判断是否当前元素个数是否查过了阈值，而不再判断当前put进来的元素对应的数组下标位置是否有值。
5. JDK7中是先扩容再添加新元素，JDK8中是先添加新元素然后再扩容

JDK8中链表转变为红黑树的条件

1. 链表中的元素的个数为8个或超过8个
2. 同时，还要满足当前数组的长度大于或等于64才会把链表转变为红黑树。为什么？因为链表转变为红黑树的目的是为了解决链表过长，导致查询和插入效率慢的问题，而如果要解决这个问题，也可以通过数组扩容，把链表缩短也可以解决这个问题。所以在数组长度还不太长的情况，可以先通过数组扩容来解决链表过长的问题。

HashMap扩容流程是怎样的

1. HashMap的扩容指的就是数组的扩容， 因为数组占用的是连续内存空间，所以数组的扩容其实只能新开一个新的数组，然后把老数组上的元素转移到新数组上来，这样才是数组的扩容
2. 在HashMap中也是一样，先新建一个2被数组大小的数组
3. 然后遍历老数组上的没一个位置，如果这个位置上是一个链表，就把这个链表上的元素转移到新数组上去
4. 在这个过程中就需要遍历链表，当然jdk7，和jdk8在这个实现时是有不一样的，jdk7就是简单的遍历链表上的没一个元素，然后按每个元素的hashcode结合新数组的长度重新计算得出一个下标，而重新得到的这个数组下标很可能和之前的数组下标是不一样的，这样子就达到了一种效果，就是扩容之后，某个链表会变短，这也就达到了扩容的目的，缩短链表长度，提高了查询效率
5. 而在jdk8中，因为涉及到红黑树，这个其实比较复杂，jdk8中其实还会用到一个双向链表来维护红黑树中的元素，所以jdk8中在转移某个位置上的元素时，会去判断如果这个位置是一个红黑树，那么会遍历该位置的双向链表，遍历双向链表统计哪些元素在扩容完之后还是原位置，哪些元素在扩容之后在新位置，这样遍历完双向链表后，就会得到两个子链表，一个放在原下标位置，一个放在新下标位置，如果原下标位置或新下标位置没有元素，则红黑树不用拆分，否则判断这两个子链表的长度，如果超过八，则转成红黑树放到对应的位置，否则把单向链表放到对应的位置。
6. 元素转移完了之后，在把新数组对象赋值给HashMap的table属性，老数组会被回收到

为什么HashMap在多线程扩容时会出现循环链表的问题

当采用jdk7的头插法时：
在这里插入图片描述