CopyOnWriteArrayList的底层原理——ConcurrentHashMap的扩容机制——接口和抽象类的区别—JDK，JRE，JVM三者区别和联系—ThreadLocal的底层原理

1. CopyOnWriteArrayList的底层原理

下面这位小哥总结的CopyOnWriteArrayList添加元素的原理很到位，这里必须分享一下👍
Java——多线程高并发系列之ArrayList、HashSet、HashMap集合线程不安全的解决方案：https://blog.csdn.net/weixin_43823808/article/details/120798663

1. 内部也是用数组来实现的，在向CopyOnWriteArrayList添加元素时，会复制一个新的数组，写操作在新的数组上进行，读操作在原数组上进行。
2. 写操作会加锁，防止出现并发写入丢失数据问题
3. 写操作结束后会把原数组指向新数组
4. CopyOnWriteArrayList允许在写操作时来读取数据，大大提高了读的性能，因此适合读多写少的应用场景，但是CopyOnWriteArrayList会比较占用内存，同时可能读到的数据不是实时最新的数据，所以不适合实时性要求很高的场景

1.1 向CopyOnWriteArrayList中添加元素源码

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

1.2 读取元素源码

public E get(int index) {
    return get(getArray(), index);
}

2. ConcurrentHashMap的扩容机制

关于这个扩容实现的原理，下边这位小哥总结的很到位👍
Java集合源码剖析——基于JDK1.8中ConcurrentHashMap的实现原理：https://blog.csdn.net/weixin_43823808/article/details/126732474

2.1 ConcurrentHashMap1.7版本

1. 1.7版本的ConcurrentHashMap是基于Segment分段实现的
2. 每个Segment相对于一个小型的HashMap
3. 每个Segment内部会进行扩容，和HashMap的扩容逻辑类似
4. 先生成新的数组，然后转移元素到新数组中
5. 扩容的判断也是每个Segment内部单独判断的，判断是否超过阈值

2.2 ConcurrentHashMap1.8版本

1. 1.8版本的ConcurrentHashMap不再基于Segment实现
2. 当某个线程进行put时，如果发现ConcurrentHashMap正在进行扩容那么该线程一起进行扩容
3. 如果某个线程put时，发现没有正在进行扩容，则将key-value添加到ConcurrentHashMap中，然后判断是否超过阈值，超过了则进行扩
4. ConcurrentHashMap是支持多个线程同时扩容的
5. 扩容之前也先生成一个新的数组
6. 在转移元素时，先将原数组分组，将每组分给不同的线程来进行元素的转移，每个线程负责一组或多组的元素转移工作

3. 接口和抽象类的区别

1. 抽象类可以存在普通成员函数，而接口中只能存在public abstract方法。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的。
3. 抽象类只能继承一个，接口可以实现多个。

3.1 设计的目的不同

接口的设计目的，是对类的行为进行约束(更准确的说是一种"有"约束，因为接口不能规定类不可以有什么行为)，也就是提供一种机制，可以强制要求不同的类具有相同的行为。它只约束了行为的有无，但不对如何实现行为进行限制。

而抽象类的设计目的，是代码复用。当不同的类具有某些相同的行为(记为行为集合A)，且其中一部分行为的实现方式一致时(A的非真子集，记为B)，可以让这些类都派生于一个抽象类。在这个抽象类中实现了B，避免让所有的子类来实现B，这就达到了代码复用的目的。而A减B的部分，留给各个子类自己实现。正是因为A-B在这里没有实现，所以抽象类不允许实例化出来（否则当调用到A-B时，无法执行)。

3.2 本质的不同

抽象类是对类本质的抽象，表达的是is a的关系，比如: BMW is a Car。抽象类包含并实现子类的通用特性，将子类存在差异化的特性进行抽象，交由子类去实现。
而接口是对行为的抽象，表达的是like a的关系。比如: Bird like a Aircraft(像飞行器一样可以飞)，但其本质上is a Bird。接口的核心是定义行为，即实现类可以做什么，至于实现类主体是谁、是如何实现的，接口并不关心。

使用场景: 当你关注一个事物的本质的时候，用抽象类;当你关注一个操作的时候，用接口。
抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是)每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度

4 JDK，JRE，JVM三者区别和联系

JDK = JRE + Java工具
JRE = JVM + 类库

5. ThreadLocal的底层原理

1. ThreadLocal是Java中所提供的线程本地存储机制，可以利用该机制将数据缓存在某个线程内部，该线程可以在任意时刻、任意方法中获取缓存的数据
2. ThreadLocal底层是通过ThreadLocalMap来实现的，每个Thread对象(注意不是ThreadLocal对象)中都存在一个ThreadLocalMap，Map的key为ThreadLocal对象，Map的value为需要缓存的值
3. 如果在线程池中使用ThreadLocal会造成内存泄漏，因为当ThreadLocal对象使用完之后，应该要把设置的key，value，也就是Enty对象进行回收，但线程池中的线程不会回收，而线程对象是通过强引用指向ThreadLocalMap，ThreadLocalMap也是通过强引用指向Enty对象，线程不被回收，Entry对象也就不会被回收，从而出现内存泄漏，解决办法是，在使用了ThreadLocal对象之后，手动调用ThreadLocal的remove方法，手动清除Entry对象
4. ThreadLocal经典的应用场景就是连接管理（一个线程持有一个连接，该连接对象可以在不同的方法之间进行传递，线程之间不共享同一个连接)

5.1 ThreadLocal 添加元素源码

Map的key为ThreadLocal对象，Map的value为需要缓存的值

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

5.2 ThreadLocal 读取元素源码

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

5.3 ThreadLocal 使用

private static ThreadLocal<String> s = new ThreadLocal<>();
public static void main(String[] args) {
    s.set("ThreadLocalValue");
    String str = s.get();
    s.remove(); //手动销毁当前线程
    System.out.println(str);
}