1.Java的List如何实现线程安全？
2.面试官问线程安全的源码List，看完再也不怕了！源码
3.关于 List 的源码线程不安全
4.ArrayList详解及扩容源码分析
5.Java 容器详解：使用与案例
6.源码详解系列(八)--全面讲解HikariCP的使用和源码

Java的List如何实现线程安全？

       Java的List如何实现线程安全？

       Collections.synchronizedList(names);效率最高，线程安全

       Java的List是我们平时很常用的集合，线程安全对于高并发的场景也十分的重要，那么List如何才能实现线程安全呢 ？

       åŠ é”

       é¦–先大家会想到用Vector，这里我们就不讨论了，首先讨论的是加锁，例如下面的代码

       public class Synchronized{

       private List<String>  names = new LinkedList<>();

       public synchronized void addName(String name ){

       names.add("abc");

       }

       public String getName(Integer index){

       Lock lock =new ReentrantLock();

       lock.lock();

       try {

       return names.get(index);

       }catch (Exception e){

       e.printStackTrace();

       }

       finally {

       lock.unlock();

       }

       return null;

       }

       }

       synchronized一加，或者使用lock 可以实现线程安全，但是这样的List要是很多个，代码量会大大增加。

       java自带类

       åœ¨java中我找到自带有两种方法

       CopyOnWriteArrayList

       CopyOnWrite 写入时复制，它使一个List同步的替代品，通常情况下提供了更好的并发性，并且避免了再迭代时候对容器的加锁和复制。通常更适合用于迭代，在多插入的情况下由于多次的复制性能会一定的下降。

       ä¸‹é¢æ˜¯add方法的源代码

          public boolean add(E e) {

       final ReentrantLock lock = this.lock; // 加锁 只允许获得锁的线程访问

       lock.lock();

       try {

       Object[] elements = getArray();

       int len = elements.length;

       // 创建个长度加1的数组并复制过去

       Object[] newElements = Arrays.copyOf(elements, len + 1);

       newElements[len] = e; // 赋值

       setArray(newElements); // 设置内部的数组

       return true;

       } finally {

       lock.unlock();

       }

       }

       Collections.synchronizedList

       Collections中有许多这个系列的方法例如

       ä¸»è¦æ˜¯åˆ©ç”¨äº†è£…饰者模式对传入的集合进行调用 Collotions中有内部类SynchronizedList

         static class SynchronizedList<E>

       extends SynchronizedCollection<E>

       implements List<E> {

       private static final long serialVersionUID = -L;

       final List<E> list;

       SynchronizedList(List<E> list) {

       super(list);

       this.list = list;

       }

       public E get(int index) {

       synchronized (mutex) { return list.get(index);}

       }

       public E set(int index, E element) {

       synchronized (mutex) { return list.set(index, element);}

       }

       public void add(int index, E element) {

       synchronized (mutex) { list.add(index, element);}

       }

       public E remove(int index) {

       synchronized (mutex) { return list.remove(index);}

       }

       static class SynchronizedCollection<E> implements Collection<E>, Serializable {

       private static final long serialVersionUID = L;

       final Collection<E> c;  // Backing Collection

       final Object mutex;     // Object on which to synchronize

       è¿™é‡Œä¸Šé¢çš„mutex就是锁的对象 在构建时候可以指定锁的对象 主要使用synchronize关键字实现线程安全

          /

**

       * @serial include

       */

       static class SynchronizedList<E>

       extends SynchronizedCollection<E>

       implements List<E> {

       private static final long serialVersionUID = -L;

       final List<E> list;

       SynchronizedList(List<E> list) {

       super(list);

       this.list = list;

       }

       SynchronizedList(List<E> list, Object mutex) {

       super(list, mutex);

       this.list = list;

       }

       è¿™é‡Œåªæ˜¯åˆ—举SynchronizedList ，其他类类似，可以看下源码了解下。

       æµ‹è¯•

       public class Main {

       public static void main(String[] args) {

       List<String> names = new LinkedList<>();

       names.add("sub");

       names.add("jobs");

       // 同步方法1 内部使用lock

       long a = System.currentTimeMillis();

       List<String> strings = new CopyOnWriteArrayList<>(names);

       for (int i = 0; i < ; i++) {

       strings.add("param1");

       }

       long b = System.currentTimeMillis();

       // 同步方法2 装饰器模式使用 synchronized

       List<String> synchronizedList = Collections.synchronizedList(names);

       for (int i = 0; i < ; i++) {

       synchronizedList.add("param2");

       }

       long c = System.currentTimeMillis();

       System.out.println("CopyOnWriteArrayList time == "+(b-a));

       System.out.println("Collections.synchronizedList time == "+(c-b));

       }

       }

       ä¸¤è€…内部使用的方法都不一样，CopyOnWriteArrayList内部是使用lock进行加锁解锁完成单线程访问，synchronizedList使用的是synchronize

       è¿›è¡Œäº†æ¬¡æ·»åŠ åŽæ—¶é—´å¯¹æ¯”如下：

       å¯ä»¥çœ‹å‡ºæ¥è¿˜æ˜¯ä½¿ç”¨äº†synchronize的集合工具类在添加方面更加快一些，其他方法这里篇幅关系就不测试了，大家有兴趣去试一下。

面试官问线程安全的List，看完再也不怕了！源码

       面试官提及线程安全的源码List时，多数求职者首先想到的源码本地源码网站是Vector，然而这只会让面试官感到失望。源码除了Vector，源码还有其他方法确保线程安全性。源码其中一种可行方案是源码使用java.util.Collections.SynchronizedList。此工具能将任何List接口的源码实现转换为线程安全的List，其构造方法如下：

       由于SynchronizedList所有方法都带同步对象锁，源码性能可能不是源码最优。面试官可能还会追问，源码特别是源码在读多写少的情况下，SynchronizedList的性能表现不佳。这时，可以引入Java并发包中的并发集合类，如CopyOnWriteArrayList和CopyOnWriteArraySet。

       CopyOnWriteArrayList，顾名思义，即复制再写入。在添加元素时，会先复制原有列表，再添加新元素。其add方法源码展示了这一过程：首先加锁，然后复制替换操作，最后释放锁。与此相对，caddcl源码其get方法源码显示，获取元素时无需加锁。这样设计使得在高并发情况下，读取性能得到显著提升，而写操作则需加锁以保证线程安全性。

       CopyOnWriteArraySet的逻辑更为简单，通过调用CopyOnWriteArrayList的addIfAbsent方法来实现去重。在添加元素时，首先判断对象是否存在，若不存在则添加。这两种并发集合适用于读多写少的情况，但在读取多写取少的场景下，使用它们并无意义，因为每次写操作都涉及集合内存复制，可能导致性能损耗，尤其当集合较大时，容易引发内存溢出问题。

       面试时，提及Vector > SynchronizedList > CopyOnWriteArrayList的线程安全List顺序，能展现对知识点的系统理解。掌握不同线程安全List的特性，有助于在面试中脱颖而出。

       总结，确保线程安全的List选择多种多样，关键在于理解不同方案的适用场景与性能特性。对于求职者而言，通过了解这些内容，不仅能在面试中表现优异，货机源码也能在工作中灵活运用。请关注Java技术栈，了解更多多线程实战用法，获取更多接地气的干货内容。

关于 List 的线程不安全

       讨论 List 数据结构在多线程环境下的安全性问题。首先，答案是否定的，因为 List 类在 Java 中并未提供线程安全的实现，以牺牲一致性保证了效率。以 ArrayList 为例，其核心方法 add(E e) 未加锁，如源码所示：

       public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; }

       为提升性能和并发性，未对并发操作进行同步处理，从而可能导致并发修改异常（ConcurrentModificationException）。通过在模拟代码中执行并发添加操作即可复现该异常。

       针对此问题，有以下几种解决策略：

       1. **使用 Vector**：Vector 类提供了线程安全的 add 方法，通过 synchronized 关键字对方法进行同步，确保并发安全。但其性能表现低于无锁的实现，特别是在高并发场景下。

       2. **利用 Collections.synchronizedList()**：此方法通过将非线程安全的 List 实例包装为同步的 List 实例，提供了一个简单的解决方式。通过以下代码即可实现：

       java

       List list = Collections.synchronizedList(new ArrayList());

       3. **采用 CopyOnWriteArrayList**：此类在添加元素时不会修改原有数据结构，而是在添加后创建新的数据结构副本。核心源码揭示了这一实现机制，具体为使用 ReentrantLock 上锁，复制现有数组，kettel源码添加元素至新数组，并最终释放锁。

       综上所述，解决 List 类线程不安全问题的常见策略包括使用 Vector、Collections.synchronizedList() 方法或 CopyOnWriteArrayList 类。每种方法都有其适用场景和性能考量，开发者应根据具体需求选择合适的解决方案。

ArrayList详解及扩容源码分析

       在集合框架中，ArrayList作为普通类实现List接口，如下图所示。

       它实现了RandomAccess接口，表明支持随机访问；Cloneable接口，表明可以实现克隆；Serializable接口，表明支持序列化。

       与其他类不同，如Vector，ArrayList在单线程环境下的线程安全性较差，但适用于多线程环境下的Vector或CopyOnWriteArrayList。

       ArrayList底层基于连续的空间实现，为动态可扩展的顺序表。

       一、构造方法解析

       使用ArrayList(Collection c)构造方法时，传入类型必须为E或其子类。

       二、扩容分析

       不带参数的构造方法初始容量为，此时底层数组为空，即`DEFAULT_CAPACITY_EMPTY_ELEMENTDATA`长度为0。

       元素添加时，信达源码默认插入数组末尾，调用`ensureCapacityInternal(size + 1)`增加容量。

       若当前容量无法满足增加需求，计算新的容量以达到所需规模，确保添加元素成功并避免频繁扩容。

       三、常用方法

       通过List.subList(int fromIndex, int toIndex)方法获取子列表，修改原列表元素亦会改变此子列表。

       四、遍历方式

       ArrayList提供for循环、foreach循环、迭代器三种遍历方法。

       五、缺陷与替代方案

       ArrayList基于数组实现，插入或删除元素导致频繁元素移动，时间复杂度高。在需要任意位置频繁操作的场景下，性能不佳。

       因此，在Java集合中引入了更适合频繁插入和删除操作的LinkedList类。

       版权声明：本文内容基于阿里云实名注册用户的贡献，遵循相关协议规定，包括用户服务协议和知识产权保护指引。发现抄袭内容，可通过侵权投诉表单举报，确保社区内容健康、合规。

Java 容器详解：使用与案例

       深入解析Java的容器世界：探索、实践与案例

       Java的容器，如同一个精致的工具箱，承载着数据和对象的管理。与C++的STL类相比，Java Collection Framework (JCF) 提供了更为丰富的功能和灵活性。让我们一起探索这个框架，理解Collection和Map的核心概念，以及它们在实际项目中的应用。

       一、Java容器概览

Collection：数据集合的基石

Set

TreeSet：基于红黑树，支持有序操作，但查找速度略慢于HashSet。

HashSet：基于哈希表，快速查找，但元素顺序不可预测。

LinkedHashSet：集合了HashSet的查找速度，同时保持插入顺序。

List

ArrayList：动态数组，随机访问高效，如Vector但线程不安全。

LinkedList：双向链表，支持顺序和批量操作，可作为栈、队列或双向队列。

PriorityQueue：基于堆结构，用于优先级队列。

Map：键值对的存储空间

TreeMap：红黑树实现，有序存储。

HashMap：哈希表，快速查找，不保证顺序。

ConcurrentHashMap：线程安全的HashMap，性能优于 Hashtable。

LinkedHashMap：链表和哈希表结合，支持顺序和LRU策略。

       二、设计模式的应用

       Java容器巧妙地运用了设计模式，如迭代器模式。Collection接口的iterator()方法生成一个Iterator，让我们能够遍历集合中的元素，从JDK 1.5开始，foreach语句让遍历变得更简洁。

       三、源码解析实战

       让我们通过ArrayList和Vector的源码，了解它们的内部结构和关键操作，如ArrayList的动态扩容、删除和序列化机制。同时，学习Vector的同步机制和CopyOnWriteArrayList的读写分离特性。

       四、容器的内存优化与选择

       理解不同容器的内存管理策略，如LinkedList的链表结构、HashMap的拉链法和WeakHashMap的弱引用，对内存敏感和性能要求高的场景尤为重要。CopyOnWriteArrayList在读多写少场景中表现出色，但需要权衡内存消耗和数据一致性。

       五、总结与建议

       掌握Java容器不仅是入门，深入理解其内部原理和算法是提升编程技能的关键。通过查阅API和源码，亲手实现容器，能让你在实际开发中游刃有余。选择合适的容器，根据项目需求定制数据结构，将极大提升代码质量和效率。

       学习Java容器，让我们在数据管理的旅程中更加自信和熟练。

源码详解系列(八)--全面讲解HikariCP的使用和源码

       源码详解系列(八)：HikariCP深度剖析

       HikariCP是一个高效数据库连接池，它的核心在于通过“池”复用连接，减少创建和关闭连接的开销。本文将全面介绍HikariCP的使用方法和源码细节。

       使用场景与内容

       本文将涉及HikariCP的以下内容：

       如何获取连接对象并进行基本操作

       项目环境设置，包括JDK、Maven版本和依赖库

       如何配置HikariCP，包括依赖引入和配置文件编写

       初始化连接池，以及通过JMX进行管理

       源码分析，重点讲解ConcurrentBag和HikariPool类，以及其创新的“标记模型”

       HikariDataSource的两个HikariPool的用意和加载配置

       核心原理

       HikariCP的性能优势主要源于其“标记模型”，通过减少锁的使用，提高并发性能。它使用CopyOnWriteArrayList来保证读操作的效率，结合CAS机制实现无锁的借出和归还操作。

       源码亮点

       源码简洁且易读，特别是ConcurrentBag类，它是HikariCP的核心组件。类结构与DBCP2类似，包含一个通用的资源池，可以应用于其他需要池化管理的场景。

       总结

       通过本文，读者可以深入了解HikariCP的工作原理，掌握其配置和使用技巧，以及源码实现。希望本文对数据库连接池有深入理解的开发者有所帮助。

       

参考资料：

HikariCP官方GitHub地址

CopyOnWriteArrayList原理分析

       JDK1.5引入并发包，CopyOnWriteArrayList应运而生，专为并发场景优化。

       CopyOnWriteArrayList利用写时复制技术实现高效读写。在多个读操作时，共享资源，写操作时复制资源，避免了锁的竞争，提升了性能。

       写时复制策略在多个读取者需要访问同一资源时，复制一份原始资源供写操作使用，保证了读操作不受影响。

       CopyOnWriteArrayList通过构造方法初始化，确保数组类型为Object[]，适应泛型转换需求，避免初始化时的类型错误。

       源码分析中，重点介绍了构造方法、add、get、remove、size和contains方法的实现。

       在add方法中，通过重载实现不同添加位置的元素添加，确保了数组的复制与元素的正确添加。

       get方法直接通过数组引用获取指定下标元素，高效快速。

       remove方法执行流程与add类似，仅在数组拷贝参数上有所调整，并在计算需要移动的元素个数时，排除待删除元素。

       size方法计算数组长度即为元素个数，因为CopyOnWriteArrayList在使用过程中内部数组始终充满元素，不存在空隙。

       contains方法通过全数组遍历检查待检索元素是否存在，根据元素是否为null进行分情况处理。

       CopyOnWriteArrayList源码分析至此结束，其高效读写特性使其在并发场景下表现优越。

线程安全的list之synchronizedList和CopyOnWriteArrayList

        在上篇文章中我们已经介绍了其他的一些list集合，如ArrayList、linkedlist等。不清楚的可以看下上篇文章 /p/ab5bf7

        但是向ArrayList这些会出现线程不安全的问题，我们该怎样解决呢？接下来就是要介绍我们线程安全的list集合synchronizedList和CopyOnWriteArrayList。

        synchronizedList的使用方式：

        从上面的使用方式中我们可以看出，synchronizedList是将List集合作为参数来创建的synchronizedList集合。

        synchronizedList为什么是线程安全的呢？

        我们先来看一下他的源码：

        我们大概贴了一些常用方法的源码，从上面的源码中我们可以看出，其实synchronizedList线程安全的原因是因为它几乎在每个方法中都使用了synchronized同步锁。

        synchronizedList官方文档中给出的使用方式是以下方式：

        在以上源码中我们可以看出，官方文档是建议我们在遍历的时候加锁处理的。但是既然内部方法以及加了锁，为什么在遍历的时候还需要加锁呢？我们来看一下它的遍历方法：

        从以上源码可以看出，虽然内部方法中大部分都已经加了锁，但是iterator方法却没有加锁处理。那么如果我们在遍历的时候不加锁会导致什么问题呢？

        试想我们在遍历的时候，不加锁的情况下，如果此时有其他线程对此集合进行add或者remove操作，那么这个时候就会导致数据丢失或者是脏数据的问题，所以如果我们对数据的要求较高，想要避免这方面问题的话，在遍历的时候也需要加锁进行处理。

        但是既然是使用synchronized加锁进行处理的，那肯定避免不了一些锁开销。有没有效率更好的方式呢？那就是我们另一个主要的并发集合CopyOnWriteArrayList。

        CopyOnWriteArrayList是在执行修改操作时，copy一份新的数组进行相关的操作，在执行完修改操作后将原来集合指向新的集合来完成修改操作。具体源码如下：

        从以上源码我们可以看出，它在执行add方法和remove方法的时候，分别创建了一个当前数组长度+1和-1的数组，将数据copy到新数组中，然后执行修改操作。修改完之后调用setArray方法来指向新的数组。在整个过程中是使用ReentrantLock可重入锁来保证不会有多个线程同时copy一个新的数组，从而造成的混乱。并且使用volatile修饰数组来保证修改后的可见性。读写操作互不影响，所以在整个过程中整个效率是非常高的。

        synchronizedList适合对数据要求较高的情况，但是因为读写全都加锁，所有效率较低。

        CopyOnWriteArrayList效率较高，适合读多写少的场景，因为在读的时候读的是旧集合，所以它的实时性不高。