alternativa a CopyOnWriteArrayList para escrituras frecuentes, iteración ocasional

Question

Tengo un ArrayList que se almacenará en caché y se compartirá entre varios subprocesos indefinidamente. Las operaciones incluyen frecuentes adiciones y eliminaciones, más iteraciones ocasionales.

Los ArrayList vidas en una clase contenedora que gestiona el acceso al mismo:

public class MyListWrapper<T> implements Iterable<T> { 

    private List<T> innerList = new ArrayList<T>(); 

    public Iterator<T> iterator() { 
     return innerList.listIterator(); 
    } 

    public void add(T element) { 
     innerList.add(element); 
     //app-specific logic 
    } 

    //remove(T), etc in the same pattern... 
} 

Actualmente estoy haciendo los preparativos para la seguridad de los subprocesos. Al principio, CopyOnWriteArrayList me pareció la mejor respuesta, pero su rendimiento me preocupa, ya que las modificaciones se realizarán con más frecuencia que cualquier otra cosa.

¿Sería un cambio manual en la clase contenedora como este ser una mejor alternativa ?:

public Iterator<T> iterator() { 
    return new ArrayList<T>(innerList).listIterator(); 
} 

//plus concurrency tweaks for any non-atomic modifications to innerList 

Por favor, me ayudan a encontrar el mejor enfoque.

Answer 1

Puede intentar usar un Collections.newSetFromMap(new ConcurrentHashMap<T, Boolean>()); Esto le dará un conjunto de hash simultáneo que le dará cerca de O (1) agregar y eliminar.

Answer 2

Una posibilidad es utilizar ConcurrentLinkedQueue si puede vivir con la interfaz Queue en lugar de la Lista. Yo diría que se pueden satisfacer más casos de uso de los esperados con una cola. Una ventaja clave de List es el acceso aleatorio (basado en el índice), pero en una situación concurrente el acceso aleatorio no es necesario ni deseable.

ConcurrentLinkedQueue es una excelente implementación concurrente de Queue.