2. 程式人生 > >多執行緒(八)： Vector與ArrayList

多執行緒(八)： Vector與ArrayList

阿新 • • 發佈：2018-11-08

ArrayList不允許寫操作沒執行完就執行讀操作，正在讀的時候不允許去寫，必須寫完再讀，讀完再寫。

一：ArrayList不安全示例

使用ArrayList每次列印的集合數量可能會小於10000，而使用Vector每次都是10000

public class ListTest {
    public static void main(String[] args) throws InterruptedException {
        ThreadGroup group = new ThreadGroup("myGroup");
        List list = new ArrayList<>();
        // Vector list = new Vector<>();
 

        MyRunnable runnable = new MyRunnable(list);
        for (int i = 0; i < 10000; i++) {
            new Thread(group, runnable).start();
        }

        // 保證所有執行緒都執行完畢
        while (group.activeCount() > 0) {
            Thread.sleep(10);
        }

        System.out.println(list.size());
    }
}

class
 
 MyRunnable implements Runnable {
    private List list;
    public MyRunnable(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        try {
            Thread.sleep((int)(Math.random() * 2));
        } catch (InterruptedException e) { }

        Random random = new
 
 Random();
        list.add(Thread.currentThread().getName() + "\t" + random.nextInt(100));
    }
}

ArrayList原始碼

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
   transient Object[] elementData;
   private int size;

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

    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        // 先賦值                 
        elementData[index] = element;
        // 再更新數量
        size++;
    }
}

通過原始碼可以看到ArrayList是通過一個Object[]陣列來實現的，ArrayList在新增一個元素的時候，至少需要兩步操作：1. 更新集合大小 2. 將元素新增到集合中， 即 elementData[size++] = e; (注意是size++, 而不是++size, 先使用值，然後再相加) add方法並沒做什麼同步加鎖的處理，假如有兩個執行緒，剛開始size=0； Thread-A執行緒將元素e新增到集合中，但並沒有完成自加的操作，此時size仍然為0，elementData[0] = e，然後CPU切換到Thread-1執行緒，新增e2元素，因Thread-0並沒有完成自加操作所以此時size仍然為0，Thread-1執行完所有的add操作，結果elementData[0] = e2; size=1,Thread-1執行完CPU切換到Thread-0，完成自增賦值操作，因Thread-1已經完成自層操作了，所以當時的size=1，Thread-0完成自增後size=2了，可以看到size為2，但是兩個執行緒都是對索引0的位置操作，最終集合的長度為1，狀態不一致。

elementData[size++] = e 並不是原子操作，實際上至少會被分解為4個原子操作

  1. 讀取size的值
  2. int newSize = size + 1;
  3. size = newSize;
  4. elementData[size] = e;

ArrayList是執行緒不安全的，可以通過Collections包裝成執行緒安全的集合

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

Collections: 集合工具類

package java.util;
public class Collections {
    // 將一些非執行緒安全的集合包裝成執行緒安全的集合
    public static <T> Collection<T> synchronizedCollection(Collection<T> c);
    public static <T> Set<T> synchronizedSet(Set<T> s);
    public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s);
    public static <T> List<T> synchronizedList(List<T> list){
        return (list instanceof RandomAccess ?
                new SynchronizedRandomAccessList<>(list) :
                new SynchronizedList<>(list));
    }
    public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m);
    public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m);


    // SynchronizedList
    static class SynchronizedList<E> extends SynchronizedCollection<E> implements List<E> {
        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;
        }
     } 


    // SynchronizedCollection
    static class SynchronizedCollection<E> implements Collection<E>, Serializable {
        private static final long serialVersionUID = 3053995032091335093L;

        final Collection<E> c;  // Backing Collection
        // 同步鎖
        final Object mutex;     // Object on which to synchronize

        SynchronizedCollection(Collection<E> c) {
            this.c = Objects.requireNonNull(c);
            // 同步鎖為this，當前物件
            mutex = this;
        }

        public boolean add(E e) {
            // add 方法使用了同步鎖： this
            // 同一時間只能新增一個
            synchronized (mutex) {return c.add(e);}
        }

    }  
}

示例一

public class WriteThread extends Thread {
    private final List<Integer> list;
    public WriteThread(List<Integer> list) {
        super("WriteThread");
        this.list = list;
    }

    @Override
    public void run() {
        for (int i = 0; true; i++) {
            list.add(i);
        }
    }
}
public class ReaderThread extends Thread {
    private final List<Integer> list;
    public ReaderThread(List<Integer> list) {
        super("ReaderThread");
        this.list = list;
    }

    @Override
    public void run() {
        while (true) {
            for (int n : list) {
                System.out.println(n);
            }
        }
    }
}
public class Main {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        new WriteThread(list).start();
        new ReaderThread(list).start();
    }
}
Exception in thread "ReaderThread" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
    at java.util.ArrayList$Itr.next(ArrayList.java:851)
    at com.company.example.chapter02.example2.ReaderThread.run(ReaderThread.java:25)

示例2

public static void main(String[] args) {
    // 包裝成同步集合
    final List<Integer> list = Collections.synchronizedList(new ArrayList<>());
    // SynchronizedCollection#add 已經加了同步鎖this，所以不會發生同步寫
    new WriteThread(list).start();
    // 雖然寫與寫不會同步，但是目前寫的同時可以讀，這樣是不行的，必須保證寫的時候不能讀，讀的時候不能寫
    // 所以在讀的時候也要加鎖，而且讀的時候加的鎖必須和寫的鎖一致
    // 如果能保證讀與寫互斥，寫與寫互斥就沒有執行緒安全問題
    // 注意：雖然Collections.synchronizedList是執行緒安全的，但是並不是說你的程式也安全，同時也要保證自己的邏輯也要安全
    new ReaderThread(list).start();
}

public class ReaderThread extends Thread {
    // ...

    @Override
    public void run() {
        while (true) {
            // 讀寫互斥
            synchronized (list) {
                for (int n : list) {
                    System.out.println(n);
                }
            }
        }
    }
}

示例三
CopyOnWriteArrayList是執行緒安全的，copy-on-write：寫時複製，當對集合執行寫操作是，內部已確保安全的陣列就會被整體複製，複製之後，就無需在使用迭代器依次讀取元素時擔心元素被修改了，所以在讀時也不會發生java.util.ConcurrentModificationException

public static void main(String[] args) {
    // WriteThread 和 ReaderThread 和示例一完全一樣
    // 只需要使用CopyOnWriteArrayList
    final List<Integer> list = new CopyOnWriteArrayList<>();

    new WriteThread(list).start();
    new ReaderThread(list).start();
}

CopyOnWriteArrayList

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

    // 鎖
    final transient ReentrantLock lock = new ReentrantLock();
    // 陣列
    private transient volatile Object[] array;


    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;
            // 將新陣列整體複製給array
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }


    final Object[] getArray() {
        return array;
    }

    final void setArray(Object[] a) {
        array = a;
    }


    // get無需加鎖
    public E get(int index) {
        return get(getArray(), index);
    }   
}

使用copy-on-write時，每次執行寫操作都會執行復制。因此頻繁執行寫操作時，如果使用CopyOnWriteArrayList會比較花費時間，如果寫操作較少讀操作較多就非常適用該集合。

Vector

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

    protected Object[] elementData;
    protected int elementCount;

    // 執行緒安全，使用synchronized
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
   }
}

將上面的list宣告為Vector可以看到每次執行集合的長度都是10000

三：Vector與ArrayList比較

Vector與ArrayList主要在於執行緒安全和效能上的區別。

  • Vector與ArrayList本質上都是一個Object[] 陣列，ArrayList提供了size屬性，Vector提供了elementCount屬性，他們的作用是記錄集合內有效元素的個數。
  • Vector是執行緒安全的集合類，ArrayList並不是執行緒安全的類。Vector類對集合的元素操作時都加了synchronized，保證執行緒安全。
  • Vector與ArrayList的擴容並不一樣，Vector預設擴容是增長一倍的容量，Arraylist是增長50%的容量。
  • Vector與ArrayList的remove,add(index,obj)方法都會導致內部陣列進行資料拷貝的操作，這樣在大資料量時，可能會影響效率。

相關推薦

多執行緒(八)： Vector與ArrayList

ArrayList不允許寫操作沒執行完就執行讀操作，正在讀的時候不允許去寫，必須寫完再讀，讀完再寫。 一：ArrayList不安全示例 使用ArrayList每次列印的集合數量可能會小於10000，而使用Vector每次都是10000 public class ListTes

多執行緒之：Synchronized與ReentrantLock

什麼是執行緒安全 保證多執行緒環境下共享的、可修改的狀態的正確性。(這裡的狀態在程式中可以看作為資料) 反著來說則是如果狀態非共享、不可修改，也就不存線上程安全的問題 保證執行緒安全的兩種方法 封裝，通過封裝將物件內部狀態隱藏、保護起來 不可變，將狀態改為

Java併發（十八）：阻塞佇列BlockingQueue BlockingQueue（阻塞佇列）詳解 二叉堆(一)之 圖文解析 和 C語言的實現 多執行緒程式設計：阻塞、併發佇列的使用總結 Java併發程式設計：阻塞佇列 java阻塞佇列 BlockingQueue（阻塞佇列）詳解

阻塞佇列（BlockingQueue）是一個支援兩個附加操作的佇列。 這兩個附加的操作是：在佇列為空時，獲取元素的執行緒會等待佇列變為非空。當佇列滿時，儲存元素的執行緒會等待佇列可用。 阻塞佇列常用於生產者和消費者的場景，生產者是往佇列裡新增元素的執行緒，消費者是從佇列裡拿元素的執行緒。阻塞佇列就是生產者

Python學習【第24篇】：死鎖，遞迴鎖，訊號量，Event事件，執行緒Queue python併發程式設計之多執行緒2------------死鎖與遞迴鎖，訊號量等

python併發程式設計之多執行緒2------------死鎖與遞迴鎖，訊號量等 一、死鎖現象與遞迴鎖 程序也是有死鎖的 所謂死鎖： 是指兩個或兩個以上

多執行緒六：死鎖例子與排查

死鎖產生情況：雙方互相持有對方的鎖的情況死鎖示例程式碼：public class DealThread implements Runnable { public String username; p

談談C#多執行緒開發：並行、併發與非同步程式設計

閱讀導航 一、使用Task 二、並行程式設計 三、執行緒同步 四、非同步程式設計模型 五、多執行緒資料安全 六、異常處理   概述 現代程式開發過程中不可避免會使用到多執行緒相關的技術，之所以要使用多執行緒，主要原因或目的大致有以下幾個： 1、 業務特性決定程式就是多工的，比如，一邊採集資料、一邊分

多執行緒三： NSThread 面試題

- (void)viewDidLoad { [super viewDidLoad]; NSThread *thread = [[NSThread alloc] initWithBlock:^{ NSLog(@"1"); }]; [thread st

多執行緒二：performSelector:withObject:afterDelay:方法

面試題： 列印結果是：1、3 原因 performSelector:withObject:afterDelay:的本質是往Runloop中新增定時器 子執行緒預設沒有啟動Runloop 一、方法的含義 [self performSelector:@selector(t

多執行緒(六)：volatile

一：執行緒無法終止 public class MyThread extends Thread { private static boolean flag = true; @Override public void run() { System

多執行緒(五)： CAS無鎖機制

java程式設計規範中long與double操作並不是原子的，在java的部分執行環境中，對於long以及double的操作並不是原子的。 例如有一個long型別的longfield欄位，某個執行緒正在執行:longfield = 123L ;這樣的指定操作，而同時有另一個執行緒正在

多執行緒(四)：鎖

當我們修改多個執行緒共享的例項時，例項就會失去安全性，所以我們應該仔細找出例項狀態不穩定的範圍，將這個範圍設為臨界區，並對臨界區進行保護，使其只允許一個執行緒同時執行。Java使用synchronized或Lock來定義臨界區，保護多個執行緒共享的欄位。 例項的全域性變數(共享資源)

多執行緒(十)： 併發中集合ConcurrentHashMap

public class HashTest { static Map<String, String> map = new HashMap<>(); public static void main(String[] args) {

多執行緒(七)：ThreadLocal

多個執行緒共享同一個物件，所有執行緒都操作同一個物件。 public class ThreadLocalTest { public static void main(String[] args) { // 三個執行緒每個執行緒列印3次，所以從0列印到9

多執行緒(九)： HashTable、HashMap和ConcurrentHashMap

public class HashTest { static Map<String, Integer> map = new HashMap<String, Integer>(); // static Map<String, Integer&g

多執行緒基礎4 同步與通訊

 1.什麼情況下需要同步 當多執行緒併發執行同一程式碼時 希望某一段程式碼執行的過程中CPU不要切換到其他執行緒工作. 這時就需要同步.   2.同步程式碼塊 使用synchronized關鍵字加上一個鎖物件來定義一段程式碼, 這就叫同步程式碼塊 多個同步程式碼塊

多執行緒同步：基於棧式同步

    什麼是基於棧式同步？這是一種完全基於非同步環境的執行緒處理之間的同步，可能這讓人有些難以理解，但我們想想一下當你開闢了多條執行緒用於處理某種事物的時候，例如你訪問 Redis 中的 Set 介面，大多數的客戶端都需要阻塞當前執行緒，由另一個執行緒發射訊號通知核心停止阻塞（

多執行緒(一)：建立執行緒的幾種方法

概括來說就是兩種：1、繼承Thread類，重寫run方法，然後start。不推薦這種，因為java的單繼承特性。 2、Thread類的建構函式中可以接受Runnable任務，所以只要是Runnable例項就可以作為引數給Thread 一般有兩種建立Runnable例項的方法（1）實現Runn

多執行緒程式設計之Runnable與Callable區別

Runnable @FunctionalInterface public interface Runnable { /** * When an object implementing interface <code>Runnable</code> is used

多執行緒面試：執行緒鎖+執行緒池+執行緒同步等

1、併發程式設計三要素？ 1）原子性 原子性指的是一個或者多個操作，要麼全部執行並且在執行的過程中不被其他操作打斷，要麼就全部都不執行。 2）可見性 可見性指多個執行緒操作一個共享變數時，其中一個執行緒對變數進行修改後，其他執行緒可以立即看到修改的結果。 實現可見性的方法

【多執行緒】Thread.interrupted()與thread.isInterrupted()的區別

在Java的執行緒基本操作方法中，有兩種方式獲取當前執行緒的isInterrupt屬性。一種是物件方法thread.isInterrupted()，另一種是Thread類的靜態方法Thread.interrupted()。這兩個方法看似相同，實際上是有區別的，我們來看看Jav