JAVA同步容器和併發容器

時間 2019-11-17

標籤 java 同步容器併發欄目 Java 简体版

原文原文鏈接

同步容器類

同步容器類的建立

在早期的JDK中，有兩種現成的實現，Vector和Hashtable，能夠直接new對象獲取；html

在JDK1.2中，引入了同步封裝類，能夠由Collections.synchronizedXxxx等方法建立；java

同步容器類的問題

同步容器類雖然都是線程安全的，可是在某些狀況下（複合操做），仍然須要加鎖來保護；數組

常見覆合操做以下：安全

迭代：反覆訪問元素，直到遍歷徹底部元素；
跳轉：根據指定順序尋找當前元素的下一個（下n個）元素；
條件運算：例如若沒有則添加等；

舉個條件運算的例子，代碼以下：併發

package concurrency.old;

import java.util.Vector;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//線程任務類，獲取集合中的最後一個元素
class GetLast implements Runnable{

    private Vector<Integer> list;
    
    public GetLast(Vector<Integer> list) {
        this.list = list;
    }
    @Override
    public void run() {
        while(true){
            try{
                Test.getLast(list);
            }catch(Exception e){
                e.printStackTrace();
                System.out.println(e.getMessage() + " --- in class GetLast");
                break;
            }
            
        }
        
    }
    
}
//線程任務類，刪除&添加元素
class DeleteAndAdd implements Runnable{

    private Vector<Integer> list;
    
    public DeleteAndAdd(Vector<Integer> list) {
        this.list = list;
    }
    @Override
    public void run() {
        while(true){
            try{
                Test.deleteAndAdd(list);
            }catch(Exception e){
                e.printStackTrace();
                System.out.println(e.getMessage() + " --- in class DeleteAndAdd");
                break;
            }
            
        }
        
    }
    
}

public class Test {

    //獲取最後一個元素
    public static  Integer getLast(Vector<Integer> list){
        //這裏根據list.size()獲得最後一個元素的索引
        //換句話說，這條語句已經檢查認爲在集合list中存在索引爲list.size() - 1的元素
        int lastIndex = list.size() - 1;
        
        if(lastIndex < 0) return null;
        
        //返回指定索引處的元素
        return list.get(lastIndex);
    }
    
    //刪除元素，添加元素
    public static  void deleteAndAdd(Vector<Integer> list){
        int lastIndex = list.size() - 1;
        if(lastIndex < 0) return;
        list.remove(lastIndex);
        list.add(3);
    }
    
    public static void main(String[] args) {
        Vector<Integer> vector = new Vector<Integer>();
        vector.add(1);
        vector.add(2);
        
        ExecutorService exec = Executors.newCachedThreadPool();
        
        GetLast gl = new GetLast(vector);
        DeleteAndAdd daa = new DeleteAndAdd(vector);
        
        exec.execute(gl);
        exec.execute(daa);
        
    }
}

運行以上程序，很快發如今getLast中拋出了java.lang.ArrayIndexOutOfBoundsException異常，緣由在於getLast方法不是原子操做，調用size方法和get方法之間，其它線程執行了remove操做，致使容器大小變小，索引訪問越界，拋出異常。ide

若想獲得正確結果，可修改代碼，對getLast和deleteAndAdd方法裏的操做加鎖（由於Vector內部是經過自身對象做爲鎖的，因此這裏一樣以Vector對象做爲鎖），使之成爲原子操做，以下代碼：性能

    //獲取最後一個元素
    public static  Integer getLast(Vector<Integer> list){
        synchronized(list){
            //這裏根據list.size()獲得最後一個元素的索引
            //換句話說，這條語句已經檢查認爲在容器list中存在索引爲list.size() - 1的元素
            int lastIndex = list.size() - 1;
            
            if(lastIndex < 0) return null;
            
            //返回指定索引處的元素
            return list.get(lastIndex);
        }
    }
    
    //刪除元素，添加元素
    public static  void deleteAndAdd(Vector<Integer> list){
        synchronized(list){
            int lastIndex = list.size() - 1;
            if(lastIndex < 0) return;
            list.remove(lastIndex);
            list.add(3);
        }
    }

另外，在對vector的元素遍歷時（for循環方式），其它線程刪除了容器中的一個元素，也會拋出異常java.lang.ArrayIndexOutOfBoundsException異常，緣由與上面提到的getLast方法同樣，在訪問最後一個元素的時候越界了；this

        for(int i = 0; i < vector.size(); i++){
            System.out.println(vector.get(i));
        }

一個可行的修改方式一樣是對容器加鎖，但代價較大，致使其它線程在迭代期間不能訪問容器，下降了併發性；spa

        synchronized(vector){
            for(int i = 0; i < vector.size(); i++){
                System.out.println(vector.get(i));
            }
        }

迭代器及快速失敗機制

同步容器與非同步容器同樣，在迭代期間，若其它線程併發修改該容器，會拋出ConcurrentModificationException異常，即快速失敗機制，以前有寫過相關內容，詳見下面連接：線程

http://www.cnblogs.com/chenpi/p/5270990.html

經過在容器迭代期間對容器加鎖來解決該問題是一種方式，但併發性差，當容器規模大時，更加嚴重，並且還可能產生死鎖問題；一種更優的解決方式，如上面連接裏提到的，採用克隆容器（CopyOnWriteArrayList等），在副本上進行操做，但存在顯著的性能開銷，須要拷貝數組等操做，這種方式的好壞要看具體需求，如容器大小，執行的具體操做，調用頻率等，通常當迭代操做遠多於修改操做時，比較適用克隆容器；

另外，在集合中，有一些隱藏的迭代操做，如toString，equals，hashCode等方法，使用時需注意，也可能會拋出ConcurrentModificationException異常；