Java中ArrayList同步的2种方法分享

柔情只为你懂 2024-03-30 08:55 47阅读 0赞

## Java中ArrayList同步的2种方法分享 ##

`arrayList` 的实现是默认不同步的。这意味着如果一个线程在结构上修改它并且多个线程同时访问它，它必须在外部同步。结构修改意味着从列表中添加或删除元素或显式调整后备数组的大小。改变现有元素的值不是结构修改。

**有两种方法可以创建同步Arraylist：**

*  1.  Collections.synchronizedList() 方法。
 *  1.  使用 CopyOnWriteArrayList。

### 方法1：使用 Collections.synchronizedList() 方法 ###

要进行串行访问，必须通过返回列表完成对后备列表的所有访问。

在迭代返回的列表时，用户必须手动同步它。因为在执行add()等方法的时候是加了`synchronized`关键字的,但是iterator()却没有加。所以在使用的时候需要加上`synchronized`。

// Java program to demonstrate working of
    // Collections.synchronizedList
    import java.util.*;
    
    class GFG
    {
        public static void main (String[] args)
        {
            List<String> list =
            Collections.synchronizedList(new ArrayList<String>());
    
            list.add("practice");
            list.add("code");
            list.add("quiz");
    
            synchronized(list)
            {
                // must be in synchronized block
                Iterator it = list.iterator();
    
                while (it.hasNext())
                    System.out.println(it.next());
            }
        }
    }

### 方法 2：使用 CopyOnWriteArrayList ###

`ArrayList` 的线程安全变体，其中所有可变操作（例如添加、设置、删除...）都是通过创建底层数组的单独副本来实现的。它通过创建 List 的单独副本来实现线程安全，这与 vector 或其他集合用于提供线程安全的方式不同。

*  当我们不能或不想同步遍历，但需要防止并发线程之间的干扰时，它很有用。
 *  这是昂贵的，因为每次写入操作都涉及单独的数组副本（例如添加，设置，删除......）
 *  当你有List并且需要遍历它的元素并且不经常修改它时，它是非常有效的。

即使在创建迭代器后修改了 `copyOnWriteArrayList`，迭代器也不会抛出`ConcurrentModificationException`，因为迭代器正在迭代 ArrayList 的单独副本，而写操作正在 ArrayList 的另一个副本上发生。

// Java program to illustrate the thread-safe ArrayList.
    import java.io.*;
    import java.util.Iterator;
    import java.util.concurrent.CopyOnWriteArrayList;
    
    class GFG
    {
        public static void main (String[] args)
        {
            // creating a thread-safe Arraylist.
            CopyOnWriteArrayList<String> threadSafeList
                = new CopyOnWriteArrayList<String>();
    
            // Adding elements to synchronized ArrayList
            threadSafeList.add("geek");
            threadSafeList.add("code");
            threadSafeList.add("practice");
    
            System.out.println("Elements of synchronized ArrayList :");
    
            // Iterating on the synchronized ArrayList using iterator.
            Iterator<String> it = threadSafeList.iterator();
    
            while (it.hasNext())
                System.out.println(it.next());
        }
    }
    码

**如果我们尝试通过迭代器自己的方法修改 CopyOnWriteArrayList 会发生什么？**

如果您尝试通过迭代器自己的方法（例如 add()、set()、remove()）修改`CopyOnWriteArrayList`，它会抛出 [UnsupportedOperationException][] 。

// Java program to illustrate the thread-safe ArrayList
    import java.io.*;
    import java.util.Iterator;
    import java.util.concurrent.CopyOnWriteArrayList;
    
    class GFG
    {
        public static void main (String[] args)
        {
            // creating a thread-safe Arraylist.
            CopyOnWriteArrayList<String> threadSafeList =
                new CopyOnWriteArrayList<String>();
    
            // Adding elements to synchronized ArrayList
            threadSafeList.add("geek");
            threadSafeList.add("code");
            threadSafeList.add("practice");
    
            System.out.println("Elements of synchronized ArrayList :");
    
            // Iterating on the synchronized ArrayList using iterator.
            Iterator<String> it = threadSafeList.iterator();
    
            while (it.hasNext())
            {
                String str = it.next();
                it.remove();
            }
        }
    }

**CopyOnWriteArrayList 的其他构造函数：**

*  1.  **CopyOnWriteArrayList(Collection<? extends E> c)：** 创建一个包含指定集合元素的列表，按照集合迭代器返回的顺序。
 *  1.  **CopyOnWriteArrayList(E\[\] toCopyIn)：** 创建一个包含给定数组副本的列表。

### 向量同步时为什么要使用arrayList？ ###

*  **性能：** `Vector` 是同步和线程安全的，因此，它比 `ArrayList` 稍慢。
 *  **功能：** Vector 在每个单独的操作级别进行同步。通常，程序员喜欢同步整个操作序列。同步单个操作既不安全又慢。
 *  **Vectors obsolete：** 向量被认为是过时的，并且在 java 中被非正式地弃用。此外，vector 对几乎从未完成的每个单独操作进行同步。大多数java程序员更喜欢使用`ArrayList`，因为如果他们需要进行同步，他们可能无论如何都会显式地同步arrayList。

以下是 Java 中 `ArrayList` 和 `CopyOnWriteArrayList` 类之间的显着差异。

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>数组列表</th> 
   <th>复制写入数组列表</th> 
   <th>删除操作</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>同步</td> 
   <td>ArrayList 不同步。</td> 
   <td>CopyOnWriteArrayList 是同步的。</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>线程安全</td> 
   <td>ArrayList 不是线程安全的。</td> 
   <td>CopyOnWriteArrayList 是线程安全的。</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>迭代器类型</td> 
   <td>ArrayList 迭代器是快速失败的，如果在迭代过程中发生并发修改，则 ArrayList 会抛出 ConcurrentModificationException。</td> 
   <td>CopyOnWriteArrayList 是故障安全的，它在迭代过程中永远不会抛出 ConcurrentModificationException。其背后的原因是 CopyOnWriteArrayList 每次修改时都会创建一个新的数组列表。</td> 
   <td></td> 
   <td>ArrayList 迭代器支持在迭代过程中移除元素。</td> 
   <td>如果在迭代期间尝试删除元素，则 CopyOnWriteArrayList.remove() 方法会引发异常。</td> 
  </tr> 
  <tr> 
   <td>表现</td> 
   <td>ArrayList 更快。</td> 
   <td>CopyOnWriteArrayList 比 ArrayList 慢。</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>从 Java 版本开始</td> 
   <td>1.2</td> 
   <td>1.5</td> 
  </tr> 
 </tbody> 
</table>

[UnsupportedOperationException]: https://link.juejin.cn/?target=https%3A%2F%2Fdocs.oracle.com%2Fjavase%2F7%2Fdocs%2Fapi%2Fjava%2Futil%2FConcurrentModificationException.html