快捷導(dǎo)航

Java集合中的CopyOnWriteArrayList使用詳解

更新時間：2023年12月19日 10:10:06 作者：會飛的豬zhu

這篇文章主要介紹了Java集合中的CopyOnWriteArrayList使用詳解,CopyOnWriteArrayList是ArrayList的線程安全版本,從他的名字可以推測,CopyOnWriteArrayList是在有寫操作的時候會copy一份數(shù)據(jù),然后寫完再設(shè)置成新的數(shù)據(jù),需要的朋友可以參考下

前言

CopyOnWriteArrayList是ArrayList的線程安全版本，從他的名字可以推測。CopyOnWriteArrayList是在有寫操作的時候會copy一份數(shù)據(jù)，然后寫完再設(shè)置成新的數(shù)據(jù)。

CopyOnWriteArrayList

CopyOnWriteArrayList適用于讀多寫少的并發(fā)場景。

上面的圖片展示你了CopyOnWriteArrayList的類圖，可以看到它實現(xiàn)了List接口，如果去看ArrayList的類圖的話，可以發(fā)現(xiàn)也是實現(xiàn)了List接口，也就得出一句廢話，ArrayList提供的api，CopyOnWriteArrayList也提供，下文中來分析CopyOnWriteArrayList是如何來做到線程安全的實現(xiàn)讀寫數(shù)據(jù)的，而且也會順便對比ArrayList的等效實現(xiàn)為什么不支持線程安全的。

下面首先展示了CopyOnWriteArrayList中比較重要的成員：

     /** The lock protecting all mutators */
    final transient ReentrantLock lock = new ReentrantLock();
    /** The array, accessed only via getArray/setArray. */
    private transient volatile Object[] array;

可以看到，CopyOnWriteArrayList使用了ReentrantLock來支持并發(fā)操作，array就是實際存放數(shù)據(jù)的數(shù)組對象。ReentrantLock是一種支持重入的獨占鎖，任意時刻只允許一個線程獲得鎖，所以可以安全的并發(fā)去寫數(shù)組，接下來看一下CopyOnWriteArrayList是如何使用這個lock來實現(xiàn)并發(fā)寫的，下面首先展示了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();
        }
    }

當(dāng)我們往一個容器添加元素的時候，不直接往當(dāng)前容器添加，而是先將當(dāng)前容器進(jìn)行Copy，復(fù)制出一個新的容器，然后新的容器里添加元素，添加完元素之后，再將原容器的引用指向新的容器。

這樣做的好處是我們可以對CopyOnWrite容器進(jìn)行并發(fā)的讀，而不需要加鎖，因為當(dāng)前容器不會添加任何元素。

所以CopyOnWrite容器也是一種讀寫分離的思想，讀和寫不同的容器。

他的缺點：

內(nèi)存占用問題。因為CopyOnWrite的寫時復(fù)制機(jī)制，所以在進(jìn)行寫操作的時候，內(nèi)存里會同時駐扎兩個對象的內(nèi)存，舊的對象和新寫入的對象（注意:在復(fù)制的時候只是復(fù)制容器里的引用，只是在寫的時候會創(chuàng)建新對象添加到新容器里，而舊容器的對象還在使用，所以有兩份對象內(nèi)存）。

如果這些對象占用的內(nèi)存比較大，比如說200M左右，那么再寫入100M數(shù)據(jù)進(jìn)去，內(nèi)存就會占用300M，那么這個時候很有可能造成頻繁的Yong GC和Full GC。

數(shù)據(jù)一致性問題。CopyOnWrite容器只能保證數(shù)據(jù)的最終一致性，不能保證數(shù)據(jù)的實時一致性。

所以如果你希望寫入的的數(shù)據(jù)，馬上能讀到，請不要使用CopyOnWrite容器?！井?dāng)執(zhí)行add或remove操作沒完成時，get獲取的仍然是舊數(shù)組的元素】

CopyOnWriteArrayList讀取時不加鎖，只是寫入、刪除、修改時加鎖，所以一個線程X讀取的時候另一個線程Y可能執(zhí)行remove操作。

remove操作首先要獲取獨占鎖，然后進(jìn)行寫時復(fù)制操作，就是復(fù)制一份當(dāng)前的array數(shù)組，然后在復(fù)制的新數(shù)組里面刪除線程X通過get訪問的元素，比如：1。刪除完成后讓array指向這個新的數(shù)組。在線程x執(zhí)行g(shù)et操作的時候并不是直接通過全局array訪問數(shù)組元素而是通過方法的形參a訪問的，a指向的地址和array指向的地址在調(diào)用get方法的那一刻是一樣的，都指向了堆內(nèi)存的數(shù)組對象。之后改變array指向的地址并不影響get的訪問，因為在調(diào)用get方法的那一刻形參a指向的內(nèi)存地址就已經(jīng)確定了，不會改變。所以讀的仍然是舊數(shù)組。

對Arrays.copyOf的認(rèn)識

首先Arrays.copyOf(Object[] , length)，相對于數(shù)組來說，是深拷貝，但是相對于數(shù)組元素來說，只有數(shù)組為一維數(shù)組，并且元素為基本類型、包裝類、String類為深拷貝，其他都為淺拷貝(針對的是數(shù)組元素)。

代碼實例：

public class Test{
   static  class Person{
        int age ;
        String name;
        public Person(int age, String name) {
            this.age = age;
            this.name = name;
        }
       @Override
       public String toString() {
           return "Person{" +
                   "age=" + age +
                   ", name='" + name + '\'' +
                   '}';
       }
   }
    public static void main(String[] args) {
       Person[] people = new Person[2];
       Person person1 = new Person(45,"dsad");
       Person person2 = new Person(105,"zhuzhu");
       people[0] = person1;
       people[1] = person2;
        Person[] people1 = Arrays.copyOf(people,people.length+1);
        System.out.println(Arrays.toString(people));
        System.out.println(Arrays.toString(people1));
      // 兩者誰都可以改變，所以可以看出來，這個復(fù)制只是引用的復(fù)制，
     //而真正的對象其實還是同一個。
        people[0].age = 456;
        System.out.println("---------");
        System.out.println(Arrays.toString(people));
        System.out.println(Arrays.toString(people1));
    }
}

運行結(jié)果：

這里其實并沒有把具體的對象復(fù)制，而是復(fù)制了對象的引用而已。如果我們使用的是int[] 類型的數(shù)組，那么就會改變了。

代碼演示：

public class Test{
   static  class Person{
        int age ;
        String name;
        public Person(int age, String name) {
            this.age = age;
            this.name = name;
        }
       @Override
       public String toString() {
           return "Person{" +
                   "age=" + age +
                   ", name='" + name + '\'' +
                   '}';
       }
   }
    public static void main(String[] args) {
       int[] arr1 = {4,5,6};
        int[] ints = Arrays.copyOf(arr1, arr1.length);
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(ints));
        System.out.println("--------------");
        arr1[0] = 12;
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(ints));
    }
}

運行結(jié)果：

可以直觀的看到，一個數(shù)組變換了，另一個沒有變換。

下面這個相當(dāng)于是一個set(index,val)源碼方法的一個易懂的方式：

public class Test{
   static  class Person{
        int age ;
        String name;
        public Person(int age, String name) {
            this.age = age;
            this.name = name;
        }
       @Override
       public String toString() {
           return "Person{" +
                   "age=" + age +
                   ", name='" + name + '\'' +
                   '}';
       }
   }
    public static void main(String[] args) {
       Person[] people = new Person[2];
       Person person1 = new Person(45,"dsad");
       Person person2 = new Person(105,"zhuzhu");
       people[0] = person1;
       people[1] = person2;
        Person[] people1 = Arrays.copyOf(people,people.length+1);
        System.out.println(Arrays.toString(people));
        System.out.println(Arrays.toString(people));
        people1[0] = new Person(45777,"456");
        System.out.println(Arrays.toString(people));
        System.out.println(Arrays.toString(people1));
        people = people1;
        System.out.println(Arrays.toString(people));
        System.out.println(Arrays.toString(people1));
    }
}

代碼結(jié)果：