如何保证ArrayList线程安全呢?

我们都知道ArrayList不是线程安全的
    那么如何保证线程安全
	避免出现数据不一致，并发异常等问题呢？
下文笔者将讲述四种保证ArrayList

保证ArrayList线程安全的实现思路

方法一:
使用 Collections.synchronizedList() 方法：Java 提供了 Collections 类中的 synchronizedList() 方法
可以将一个普通的 ArrayList 转换成线程安全List

List<E> myArrayList = Collections.synchronizedList(new ArrayList<E>());

方法二:使用java.util.concurrent.CopyOnWriteArrayList 类:
CopyOnWriteArrayList是Java并发包(java.util.concurrent)中提供的一个线程安全的列表实现
它在读取操作上没有锁，并且支持在迭代期间进行修改操作
而不会抛出 ConcurrentModificationException 异常

CopyOnWriteArrayList<E> myArrayList = new CopyOnWriteArrayList<E>();

方法三、写一个myArrayList继承自Arraylist
然后重写或按需求编写自己的方法
这些方法要写成synchronized
在这些synchronized的方法中调用ArrayList的方法

import java.util.ArrayList;
 
public class MyArrayList<E> extends ArrayList<E> {
 
    @Override
    public synchronized boolean add(E e) {
        // 在 synchronized 方法中调用 ArrayList 的 add 方法
        return super.add(e);
    }
 
    @Override
    public synchronized void add(int index, E element) {
        // 在 synchronized 方法中调用 ArrayList 的 add 方法
        super.add(index, element);
    }
 
    @Override
    public synchronized E remove(int index) {
        // 在 synchronized 方法中调用 ArrayList 的 remove 方法
        return super.remove(index);
    }
 
    @Override
    public synchronized boolean remove(Object o) {
        // 在 synchronized 方法中调用 ArrayList 的 remove 方法
        return super.remove(o);
    }
 
    // 可以按需求继续重写其他需要同步的方法
 
    // 注意：需要根据具体的需求选择要同步的方法，不一定需要将所有方法都同步
 
}

方法四:
使用显式的锁
可以使用 java.util.concurrent.locks包中提供的显式锁(如 ReentrantLock)来手动实现对 ArrayList 的同步。
这需要在访问 ArrayList 的地方显式地获取和释放锁，
从而确保在同一时刻只有一个线程可以访问 ArrayList。

使用显式锁 (ReentrantLock) 实现对 ArrayList 进行同步的示例代码：

import java.util.ArrayList;
import java.util.concurrent.locks.ReentrantLock;
 
public class MyArrayList<E> {
 
    private ArrayList<E> arrayList = new ArrayList<>();
    private ReentrantLock lock = new ReentrantLock();
 
    public void add(E e) {
        lock.lock();
        try {
            // 在锁内部调用 ArrayList 的 add 方法
            arrayList.add(e);
        } finally {
            lock.unlock();
        }
    }
 
    public void add(int index, E element) {
        lock.lock();
        try {
            // 在锁内部调用 ArrayList 的 add 方法
            arrayList.add(index, element);
        } finally {
            lock.unlock();
        }
    }
 
    public E remove(int index) {
        lock.lock();
        try {
            // 在锁内部调用 ArrayList 的 remove 方法
            return arrayList.remove(index);
        } finally {
            lock.unlock();
        }
    }
 
    public boolean remove(Object o) {
        lock.lock();
        try {
            // 在锁内部调用 ArrayList 的 remove 方法
            return arrayList.remove(o);
        } finally {
            lock.unlock();
        }
    }
 
    // 可以按需求继续实现其他需要同步的方法
 
}