Resumen de la comparación de seguridad de subprocesos de List en la colección Java (comparación de rendimiento)

prefacio

Presente tres formas de instalar el complemento es-head
1. Instalación del complemento del navegador de Google Google浏览器插件, acceso directo a Elasticsearch
2. Instalación de npm 下载源码, compilación e instalación, ejecución del complemento en el entorno nodejs

---

1. Antecedentes

Cuando la lista de recopilación se usa en varios subprocesos, habrá un problema de inseguridad en los subprocesos. Por lo tanto, investigamos todas las listas de colecciones seguras para subprocesos y utilizamos pruebas simples para probar el rendimiento correspondiente.
Lista segura para subprocesos:

List<Integer> vector = new Vector<>();
List<Integer> listSyn = Collections.synchronizedList(new ArrayList<>());
List<Integer> copyList = new CopyOnWriteArrayList<>();

2. prueba

package com.example.jkytest.juc;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

public class ListTest {
    
    


    // static List<Integer> list = new ArrayList<>();

    static List<Integer> vector = new Vector<>();
    static List<Integer> listSyn = Collections.synchronizedList(new ArrayList<>());
    static List<Integer> copyList = new CopyOnWriteArrayList<>();

    public static void main(String[] args) throws InterruptedException {
    
    
        // 设置并发数
        int num = 100;
        List<List<Integer>> all = Arrays.asList(vector, listSyn, copyList);
        for (List<Integer> list : all) {
    
    
            long start = System.currentTimeMillis();
            test(num, list);
            System.out.println("------耗时：" + (System.currentTimeMillis() - start));
            // 等待上述所有线程执行完
            Thread.sleep(2 * 1000);
        }
    }

    /**
     * @param num  循环次数
     * @param list 集合
     */
    public static void test(int num, List<Integer> list) {
    
    
        for (int i = 0; i < num; i++) {
    
    
            new Thread(() -> list.add(Math.round(0))).start();
        }
    }
}

El resultado de la ejecución:

número concurrente	100	1000	10000
Vector	74	148	836
Colecciones	11	49	716
CopyOnWriteArrayList	14	59	512

Tres, explicación detallada

• El subproceso ArrayList no es seguro: principalmente cuando los subprocesos múltiples escriben datos, habrá problemas de escritura repetidos

• Seguridad de subprocesos vectoriales: principalmente al agregar elementos, se agrega sincronizado

public synchronized E set(int index, E element) {
    
    
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
 
        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

• Collections.synchronizedList: Principalmente también se sincroniza un marco de colección grande

        public boolean add(E e) {
    
    
            synchronized (mutex) {
    
    return c.add(e);}
        }

• CopyOnWriteArrayList: use principalmente ReentrantLock, cada vez que se agregue un elemento, los datos antiguos se copiarán en la nueva matriz y el bloqueo se usará al mismo tiempo

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();
        }
}

Cuatro Resumen

ArrayList utilizado en un solo hilo

En subprocesos múltiples, 2000以内use Collections.synchronizedList2000以上 simultáneamente; use CopyOnWriteArrayList simultáneamente ; Vector es una colección que existe en la versión JDK1.1, que es un peso pesado y no se recomienda .

---

Resumir

Si este artículo es útil para usted, espero que los grandes puedan 关注apoyar una ola , ¡muchas gracias! ¡¡¡Por favor, corríjame si estoy equivocado!!!点赞收藏评论

Referencia 1