java併發程式設計：同步容器

eddie小英俊發表於2016-06-15
Java程式設計

Java併發程式設計：同步容器

　　為了方便編寫出執行緒安全的程式，Java裡面提供了一些執行緒安全類和併發工具，比如：同步容器、併發容器、阻塞佇列、Synchronizer（比如CountDownLatch）。今天我們就來討論下同步容器。

　　以下是本文的目錄大綱：

　　一.為什麼會出現同步容器？

　　二.Java中的同步容器類

　　三.同步容器的缺陷

　　若有不正之處請多多諒解，並歡迎批評指正。

　　請尊重作者勞動成果，轉載請標明原文連結：

　　http://www.cnblogs.com/dolphin0520/p/3933404.html

一.為什麼會出現同步容器？

　　在Java的集合容器框架中，主要有四大類別：List、Set、Queue、Map。

　　List、Set、Queue介面分別繼承了Collection介面，Map本身是一個介面。

　　注意Collection和Map是一個頂層介面，而List、Set、Queue則繼承了Collection介面，分別代表陣列、集合和佇列這三大類容器。

　　像ArrayList、LinkedList都是實現了List介面，HashSet實現了Set介面，而Deque（雙向佇列，允許在隊首、隊尾進行入隊和出隊操作）繼承了Queue介面，PriorityQueue實現了Queue介面。另外LinkedList（實際上是雙向連結串列）實現了了Deque介面。

　　像ArrayList、LinkedList、HashMap這些容器都是非執行緒安全的。

　　如果有多個執行緒併發地訪問這些容器時，就會出現問題。

　　因此，在編寫程式時，必須要求程式設計師手動地在任何訪問到這些容器的地方進行同步處理，這樣導致在使用這些容器的時候非常地不方便。

　　所以，Java提供了同步容器供使用者使用。

二.Java中的同步容器類

　　在Java中，同步容器主要包括2類：

　　1）Vector、Stack、HashTable

　　2）Collections類中提供的靜態工廠方法建立的類

　　Vector實現了List介面，Vector實際上就是一個陣列，和ArrayList類似，但是Vector中的方法都是synchronized方法，即進行了同步措施。

　　Stack也是一個同步容器，它的方法也用synchronized進行了同步，它實際上是繼承於Vector類。

　　HashTable實現了Map介面，它和HashMap很相似，但是HashTable進行了同步處理，而HashMap沒有。

　　Collections類是一個工具提供類，注意，它和Collection不同，Collection是一個頂層的介面。在Collections類中提供了大量的方法，比如對集合或者容器進行排序、查詢等操作。最重要的是，在它裡面提供了幾個靜態工廠方法來建立同步容器類，如下圖所示：

　　

　　

三.同步容器的缺陷

　　從同步容器的具體實現原始碼可知，同步容器中的方法採用了synchronized進行了同步，那麼很顯然，這必然會影響到執行效能，另外，同步容器就一定是真正地完全執行緒安全嗎？不一定，這個在下面會講到。

　　我們首先來看一下傳統的非同步容器和同步容器的效能差異，我們以ArrayList和Vector為例：

1.效能問題

　　我們先通過一個例子看一下Vector和ArrayList在插入資料時效能上的差異：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Test {
    public static void main(String[] args) throws InterruptedException {
        ArrayList<Integer> list = new ArrayList<Integer>();
        Vector<Integer> vector = new Vector<Integer>();
        long start = System.currentTimeMillis();
        for(int i=0;i<100000;i++)
            list.add(i);
        long end = System.currentTimeMillis();
        System.out.println("ArrayList進行100000次插入操作耗時："+(end-start)+"ms");
        start = System.currentTimeMillis();
        for(int i=0;i<100000;i++)
            vector.add(i);
        end = System.currentTimeMillis();
        System.out.println("Vector進行100000次插入操作耗時："+(end-start)+"ms");
    }
}

　　這段程式碼在我機器上跑出來的結果是：

　　

　　進行同樣多的插入操作，Vector的耗時是ArrayList的兩倍。

　　這只是其中的一方面效能問題上的反映。

　　另外，由於Vector中的add方法和get方法都進行了同步，因此，在有多個執行緒進行訪問時，如果多個執行緒都只是進行讀取操作，那麼每個時刻就只能有一個執行緒進行讀取，其他執行緒便只能等待，這些執行緒必須競爭同一把鎖。

　　因此為了解決同步容器的效能問題，在Java 1.5中提供了併發容器，位於java.util.concurrent目錄下，併發容器的相關知識將在下一篇文章中講述。

2.同步容器真的是安全的嗎？

　　也有有人認為Vector中的方法都進行了同步處理，那麼一定就是執行緒安全的，事實上這可不一定。看下面這段程式碼：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Test {
    static Vector<Integer> vector = new Vector<Integer>();
    public static void main(String[] args) throws InterruptedException {
        while(true) {
            for(int i=0;i<10;i++)
                vector.add(i);
            Thread thread1 = new Thread(){
                public void run() {
                    for(int i=0;i<vector.size();i++)
                        vector.remove(i);
                };
            };
            Thread thread2 = new Thread(){
                public void run() {
                    for(int i=0;i<vector.size();i++)
                        vector.get(i);
                };
            };
            thread1.start();
            thread2.start();
            while(Thread.activeCount()>10)   {
                 
            }
        }
    }
}

　　在我機器上執行的結果：

　　

　　正如大家所看到的，這段程式碼報錯了：陣列下標越界。

　　也許有朋友會問：Vector是執行緒安全的，為什麼還會報這個錯？很簡單，對於Vector，雖然能保證每一個時刻只能有一個執行緒訪問它，但是不排除這種可能：

　　當某個執行緒在某個時刻執行這句時：

1
2
for(int i=0;i<vector.size();i++)
    vector.get(i);

　　假若此時vector的size方法返回的是10，i的值為9

　　然後另外一個執行緒執行了這句：

1
2
for(int i=0;i<vector.size();i++)
    vector.remove(i);

　　將下標為9的元素刪除了。

　　那麼通過get方法訪問下標為9的元素肯定就會出問題了。

　　因此為了保證執行緒安全，必須在方法呼叫端做額外的同步措施，如下面所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class Test {
    static Vector<Integer> vector = new Vector<Integer>();
    public static void main(String[] args) throws InterruptedException {
        while(true) {
            for(int i=0;i<10;i++)
                vector.add(i);
            Thread thread1 = new Thread(){
                public void run() {
                    synchronized (Test.class) {   //進行額外的同步
                        for(int i=0;i<vector.size();i++)
                            vector.remove(i);
                    }
                };
            };
            Thread thread2 = new Thread(){
                public void run() {
                    synchronized (Test.class) {
                        for(int i=0;i<vector.size();i++)
                            vector.get(i);
                    }
                };
            };
            thread1.start();
            thread2.start();
            while(Thread.activeCount()>10)   {
                 
            }
        }
    }
}

 3. ConcurrentModificationException異常

　　在對Vector等容器併發地進行迭代修改時，會報ConcurrentModificationException異常，關於這個異常將會在後續文章中講述。

　　但是在併發容器中不會出現這個問題。

　　參考資料：

　　《深入理解Java虛擬機器》

　　《Java併發程式設計實戰》

　　http://thinkgeek.diandian.com/post/2012-03-24/17905694

　　http://blog.csdn.net/cutesource/article/details/5780740

本文轉載自海 子部落格園部落格，原文連結：http://www.cnblogs.com/dolphin0520/p/3933404.html如需轉載自行聯絡原作者


相關文章