Java中的不安全集合類（二）

上篇文章介紹了JAVA中不安全的集合類：
Java中的不安全集合類（一)
下面我們來聊一下該如何處理這些集合

處理方式

• 使用 java.util.Vector 集合
• 使用 Collections
• 使用 java.util.CopyOnWriteArrayList集合

我們先看這幾個類的關係

如上圖所示，我們可以看到LinkedList，ArrayList，CopyandWriteArraryList，Vector 屬於同一級別下，我們來一個一個看

java.util.Vector 示例

public static void main(String[] args) {
        //新建一個Vector 集合 strings
        List<String> strings = new Vector<>();
        //循環創建線程 向strings中添加數據
        for (int i = 1; i <= 15; i++) {
            new Thread(() -> {
                strings.add(UUID.randomUUID().toString().substring(0, 2));
                System.out.println(Thread.currentThread().getName() + ":" + strings);
            }, String.valueOf(i)).start();
        }
    }

輸出結果如下圖，未發生異常，

下面我們看一下Vector中的 add() 方法

	/**
     * Appends the specified element to the end of this Vector.
     *
     * @param e element to be appended to this Vector
     * @return {@code true} (as specified by {@link Collection#add})
     * @since 1.2
     */
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

我們發現與上文看到的 ArrayList 中的 add() 方法多加了一個 synchronized 關鍵字處理
使得每次添加的方法只能有一個線程佔用
故：Vector 是一個實現線程安全的集合

java.util.Collections.synchronizedList() 示例

   List<String> strings = Collections.synchronizedList(new ArrayList<>());

創建集合時 Collections.synchronizedList() 處理，輸出結果無異常。
我們來看這個方法實現。

	public static <T> List<T> synchronizedList(List<T> list) {
        return (list instanceof RandomAccess ?
                new SynchronizedRandomAccessList<>(list) :
                new SynchronizedList<>(list));
    }

發現返回的是一個新的類 SynchronizedList 我們繼續往下看

我們找到這個類的 add() 方法

  		final Object mutex;     // Object on which to synchronize
  		
 		public void add(int index, E element) {
            synchronized (mutex) {list.add(index, element);}
        }

發現他對我們的對象本身做了一個同步鎖處理
故：Collections.synchronizedList() 可以作爲我們做一個線程安全的處理

java.util.CopyOnWriteArrayList 示例

   List<String> strings = new CopyandWriteArraryList<>();

我們來創建一個 CopyOnWriteArrayList 集合 ，輸出結果無異常。

我們來看 CopyOnWriteArrayList 集合中的 add() 方法

    /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#add})
     */
    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();
        }
    }

我們發現 他對方法做了 lock 加鎖處理
我們在添加的過程中 他做了將我們原本的集合copy 了一份 存入新的對象，最後將對象返回，這樣的話 相對會影響效率

故：CopyOnWriteArrayList 是一個 運用寫時複製技術 的線程安全集合 推薦使用

ArraySet 可使用 java.util.CopyOnWriteArraySet 來解決併發問題
HashMap 可使用 java.util.concurrent.ConcurrentHashMap 來解決併發問題