Existe uma lista simultânea no JDK do Java?

Como posso criar uma instância simultânea de List, onde posso acessar elementos por índice? O JDK tem alguma classe ou método de fábrica que eu possa usar?

Há uma implementação de lista simultânea em java.util.concurrent . CopyOnWriteArrayList em particular.

Se você não se preocupa em ter acesso baseado em índice e apenas deseja as características de preservação da ordem de inserção de uma Lista, considere um java.util.concurrent.ConcurrentLinkedQueue . Como ele implementa o Iterable, quando você terminar de adicionar todos os itens, poderá percorrer o conteúdo usando a sintaxe aprimorada:

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

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

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

É possível usar muito bem o Collections.synchronizedList (List) se tudo o que você precisa é de simples sincronização de chamada:

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

Como o ato de adquirir a posição e obter o elemento da posição especificada requer naturalmente algum bloqueio (não é possível que a lista tenha alterações estruturais entre essas duas operações).

A própria idéia de uma coleção simultânea é que cada operação por si só é atômica e pode ser feita sem bloqueio / sincronização explícita.

Portanto, colocar o elemento na posição nde uma dada Listoperação atômica não faz muito sentido em uma situação em que o acesso simultâneo é antecipado.

Você tem estas opções:

• Collections.synchronizedList(): Você pode envolver qualquer Listaplicação ( ArrayList, LinkedListou uma lista de 3rd-party). O acesso a todos os métodos (leitura e escrita) será protegido usando synchronized. Ao usar iterator()ou aprimorado para o loop, você deve sincronizar manualmente; durante a iteração, outros threads são totalmente bloqueados, mesmo na leitura. Você também pode sincronizar separadamente para cada chamada hasNexte next, mas ConcurrentModificationExceptioné possível.

• CopyOnWriteArrayList: é caro modificar, mas não tem espera para ler. Os iteradores nunca lançam ConcurrentModificationException, eles retornam um instantâneo da lista no momento da criação do iterador, mesmo que a lista seja modificada por outro encadeamento durante a iteração. Útil para listas atualizadas com pouca frequência. Operações em massa como addAllas preferidas para atualizações - a matriz interna é copiada menos vezes.

• Vector: muito parecido synchronizedList, mas a iteração também é sincronizada. No entanto, os iteradores podem lançar ConcurrentModificationException, se o vetor for modificado por outro thread durante a iteração.

Outras opções:

• Collections.unmodifiableList(): livre de trava, sem fio, mas não modificável
• Queueou Dequepode ser uma alternativa se você adicionar / remover apenas no final da lista e iterar a lista. Não há acesso por índice nem adição / remoção em locais arbitrários. Eles têm várias implementações simultâneas com melhor desempenho e melhor acesso simultâneo, mas está além do escopo desta pergunta. Você também pode dar uma olhada no JCTools , eles contêm implementações de filas com melhor desempenho, especializadas para um único consumidor ou produtor único.

CopyOnWriteArrayList é uma variante segura de thread de ArrayList na qual todas as operações mutativas (adicionar, definir e assim por diante) são implementadas fazendo uma nova cópia da matriz subjacente.

O CopyOnWriteArrayList é uma alternativa simultânea da interface List implementada e a parte sincronizada do pacote java.util.concurrent e é uma coleção segura para threads.

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

CopyOnWriteArrayList é à prova de falhas e não lança ConcurrentModificationException quando CopyOnWriteArrayList subjacente é modificado durante a Iteração, use uma cópia separada de ArrayList.

Isso geralmente é muito caro, porque a matriz de cópias envolve todas as operações de atualização em que uma cópia clonada será criada. CopyOnWriteArrayList é a melhor opção apenas para operação de leitura frequente.

/**
         * 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