Vector código fuente de análisis sintáctico y CopyOnWriteArrayList

ArrayList y LinkedList ha descrito anteriormente, en escenarios de multiproceso no son apropiados. JDK proporciona una lista de temas de seguridad.

Vector es thread-safe y CopyOnWriteArrayList

1, Vector

Las propiedades de la clase y métodos con ArrayList, la principal diferencia es el vector en sus principales métodos se combinan con la palabra clave sincronizada, de modo que para lograr una propósitos de hilo de seguridad.

 

2, análisis de código fuente CopyOnWriteArrayList

CopyOnWriteArrayList public class <E> 
    implementos Lista <E>, acceso aleatorio, Cloneable, java.io.Serializable { 
    cerradura ReentrantLock transitoria final = nueva ReentrantLock (); 

    //使用数组存储数据
    transitoria privado volátil Object [] array; 
}

　Con respecto a la ArrayList, una cerradura para caja fuerte de multi-hilo, menos tamaño de recuento　

 

3, constructor CopyOnWriteArrayList

    // 1,空构造函数
    CopyOnWriteArrayList público () { 
        setArray (nuevo Object [0]); 
    } 

    // 2,集合构造函数
    CopyOnWriteArrayList pública (Collection <extiende E?> C) { 
        Object [] elementos; 
        si (c.getClass () == CopyOnWriteArrayList.class) 
            elementos = (<?> (CopyOnWriteArrayList) c) .getArray (); 
        else { 
            elementos = c.toArray (); 
            // fuerzas c.toArray (incorrectamente) no devuelve Object [] (véase 6.260.652) 
            si (elements.getClass ()! = Object [] Class.) 
                Elementos = Arrays.copyOf (elementos, elements.length, Object []. Clase ); 
        } 
	//赋值给当前array 
        SetArray (elementos); 
    } 

    //. 3, lo digital constructor 
    CopyOnWriteArrayList pública (E [] toCopyIn) { 
        setArray (Arrays.copyOf (toCopyIn, toCopyIn.length, Object [] clase).); 
    } 
    // setArray方法
    final de setArray void (Object [] a) { 
        array = a; 
    }

　　El argumento principal se analiza en un objeto digital y, a continuación copiado a la matriz

 

 

4, operación de adición

    // 1, la adición de un solo elemento 
    pública de Boole el botón Añadir (E E) {     
    } 
    // 2, añadir un solo elemento a un lugar 
    público anular el Add (int index, E Element) { 
       
    } 
    //. 3, la adición de una colección de elementos 
    addAll public boolean ( colección <? el extiende E> C) { 
    } 

    //. 4, partiendo de una posición de ajuste para añadir 
    addAll public boolean (int index, colección <? extiende E> c) {
    

　　Análisis de los principales complemento pública booleano (E e)

    add public boolean (E e) { 
        cerradura ReentrantLock final = this.lock; 
 	// 1,获取锁对象
        lock.lock (); 
        try { 
	    // 2,增加元素
            elementos Object [] = getArray (); 
            int len = elements.length; 
            Object [] newElements = Arrays.copyOf (elementos, len + 1); 
            newElements [len] = e; 
            setArray (newElements); 
            return true; 
        } Finally { 
	    // 3,释放锁
            lock.unlock (); 
        } 
    }

　　Tenga en cuenta que: CopyOnWriteArrayList no ArrayList de expansión automática (1.5), añadir una ejecución Arrays.copyOf operación, esto se convertirá en un cuello de botella

 

5, eliminar

Buscamos principalmente

    E público Remove (int index) { 
        último bloqueo ReentrantLock = this.lock; 
	// 1,获取锁
        lock.lock (); 
        try { 
            Object [] elementos = GetArray (); 
            int len = elements.length; 
            E = get (oldValue elementos, índice); 
            int numMoved = len - index - 1; 
            si (numMoved == 0) 
                setArray (Arrays.copyOf (elementos, len - 1)); 
            else { 
                Object [] newElements = new Object [len - 1]; 
                System.arraycopy (elementos, 0, newElements, 0, índice); 
                System.arraycopy (elementos, índice + 1, newElements, índice,
                                 numMoved); 
                setArray (newElements); 
            }
            volver oldValue; 
        } Finally { 
            lock.unlock (); 
        } 
    }

　　

6, la operación de modificación

buscamos

    E público conjunto (int index, elemento E) { 
        cerradura ReentrantLock final = this.lock; 
        lock.lock (); 
        try { 
            Object [] elementos = GetArray (); 
            E = get (oldValue elementos, índice); 

            si (= oldValue elemento!) { 
		//直接获取元素,并替换
                int len = elements.length; 
                Object [] newElements = Arrays.copyOf (elementos, len); 
                newElements [índice] = elemento; 
                setArray (newElements); 
            } Else { 
                // No hace ni un no-op; asegura semántica de escritura volátiles 
                SetArray (elementos); 
            } 
            Devolver oldValue; 
        } Finally { 
            lock.unlock (); 
        } 
    }

　　

7, operación de consulta

    get privada E (Object [] a, int index) { 
        return (E) un [índice]; 
    } 

    E pública get (int index) { 
        retorno get (getArray (), índice); 
    }

　　Llegar hasta aquí no es seguro para subprocesos.

Y Vector consulta explotación, modificación sincronizada, son seguros para subprocesos.

    pública sincronizado E get (int index) { 
        si (índice> = elementCount) 
            throw new ArrayIndexOutOfBoundsException (índice); 

        retorno elementData (index); 
    }

　　Resumen: En Vector, independientemente de adiciones y supresiones operación, o la operación de consulta, todos están acoplados con el bloqueo sincronizado,

En CopyOnWriteArrayList, sólo CRUD operaciones añaden una cerradura, no hay consulta, de modo que múltiples hilos se puede acceder en paralelo.