¿Hay una lista concurrente en el JDK de Java?

¿Cómo puedo crear una instancia de Lista concurrente, donde puedo acceder a elementos por índice? ¿El JDK tiene alguna clase o método de fábrica que pueda usar?

Hay una implementación de lista concurrente en java.util.concurrent . CopyOnWriteArrayList en particular.

Si no le importa tener acceso basado en índices y solo desea las características de preservación del orden de inserción de una Lista, puede considerar un java.util.concurrent.ConcurrentLinkedQueue . Como implementa Iterable, una vez que haya terminado de agregar todos los elementos, puede recorrer los contenidos utilizando la sintaxis mejorada:

Queue<String> globalQueue = new ConcurrentLinkedQueue<String>();

//Multiple threads can safely call globalQueue.add()...

for (String href : globalQueue) {
    //do something with href
}

Puedes usar Collections.synchronizedList (List) si todo lo que necesitas es una simple sincronización de invocación:

 List<Object> objList = Collections.synchronizedList(new ArrayList<Object>());

Debido a que el acto de adquirir la posición y obtener el elemento de la posición dada, naturalmente requiere cierto bloqueo (no puede hacer que la lista tenga cambios estructurales entre esas dos operaciones).

La idea misma de una colección concurrente es que cada operación por sí sola es atómica y se puede hacer sin bloqueo / sincronización explícitos.

Por lo tanto, obtener el elemento en la posición nde una Listoperación atómica dada no tiene mucho sentido en una situación en la que se anticipa el acceso concurrente.

Tienes estas opciones:

• Collections.synchronizedList(): Se puede envolver cualquier Listaplicación ( ArrayList, LinkedListo una lista tercera parte). El acceso a todos los métodos (lectura y escritura) estará protegido mediante synchronized. Al usar iterator()o mejorar el bucle, debe sincronizarlo manualmente; mientras itera, otros hilos están completamente bloqueados incluso de la lectura. También puede sincronizar por separado para cada una hasNexty las nextllamadas, pero luego ConcurrentModificationExceptiones posible.

• CopyOnWriteArrayList: es costoso modificarlo, pero esperar para leerlo. Los iteradores nunca arrojan ConcurrentModificationException, devuelven una instantánea de la lista en el momento de la creación del iterador, incluso si la lista es modificada por otro hilo mientras itera. Útil para listas actualizadas con poca frecuencia. addAllSe prefieren las operaciones masivas como las actualizaciones: la matriz interna se copia con menos frecuencia.

• Vector: muy parecido synchronizedList, pero la iteración también está sincronizada. Sin embargo, los iteradores pueden lanzar ConcurrentModificationException, si el vector es modificado por otro hilo mientras itera.

Otras opciones:

• Collections.unmodifiableList(): sin bloqueo, seguro para subprocesos, pero no modificable
• Queueo Dequepodría ser una alternativa si solo agrega / elimina al final de la lista e itera la lista. No hay acceso por índice ni adición / eliminación en lugares arbitrarios. Tienen múltiples implementaciones concurrentes con un mejor rendimiento y un mejor acceso concurrente, pero está fuera del alcance de esta pregunta. También puede echar un vistazo a JCTools , que contienen implementaciones de cola más eficaces especializadas para un solo consumidor o un solo productor.

CopyOnWriteArrayList es una variante segura de subprocesos de ArrayList en la que todas las operaciones mutativas (agregar, establecer, etc.) se implementan haciendo una copia nueva de la matriz subyacente.

CopyOnWriteArrayList es una alternativa concurrente de la lista sincronizada implementa la interfaz List y es parte del paquete java.util.concurrent y es una colección segura para subprocesos.

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

CopyOnWriteArrayList es a prueba de fallas y no arroja ConcurrentModificationException cuando CopyOnWriteArrayList subyacente se modifica durante la iteración, use una copia separada de ArrayList.

Esto suele ser demasiado costoso porque la matriz de copia involucra cada operación de actualización, se creará una copia clonada. CopyOnWriteArrayList es la mejor opción solo para operaciones de lectura frecuente.

/**
         * Returns a shallow copy of this list.  (The elements themselves
         * are not copied.)
         *
         * @return a clone of this list
         */
        public Object clone() {
            try {
                @SuppressWarnings("unchecked")
                CopyOnWriteArrayList<E> clone =
                    (CopyOnWriteArrayList<E>) super.clone();
                clone.resetLock();
                return clone;
            } catch (CloneNotSupportedException e) {
                // this shouldn't happen, since we are Cloneable
                throw new InternalError();
            }
        }

• http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/CopyOnWriteArrayList.html

• https://docs.oracle.com/javase/9/docs/api/java/util/concurrent/CopyOnWriteArrayList.html

• https://www.logicbig.com/tutorials/core-java-tutorial/java-collections/concurrent-collection-cheatsheet.html