Comment faire pour retourner un thread-safe/immuables de la Collection en Java?

Je pense que inmodifiable est suffisant. Vous ne pouvez pas écrire, qui est ce qui provoque des problèmes pour les multi-thread d'accès. Elle est en lecture seule, donc, l'étape de synchronisation semble inutile pour moi.

Préférable de vérifier le code source quand il y a des questions de ce genre. Regarde comme elle renvoie un UnmodifiableList:

/**
* @serial include
*/
static class UnmodifiableList<E> extends UnmodifiableCollection<E>
implements List<E> {
static final long serialVersionUID = -283967356065247728L;
final List<? extends E> list;
UnmodifiableList(List<? extends E> list) {
super(list);
this.list = list;
}
public boolean equals(Object o) {return o == this || list.equals(o);}
public int hashCode()       {return list.hashCode();}
public E get(int index) {return list.get(index);}
public E set(int index, E element) {
throw new UnsupportedOperationException();
}
public void add(int index, E element) {
throw new UnsupportedOperationException();
}
public E remove(int index) {
throw new UnsupportedOperationException();
}
public int indexOf(Object o)            {return list.indexOf(o);}
public int lastIndexOf(Object o)        {return list.lastIndexOf(o);}
public boolean addAll(int index, Collection<? extends E> c) {
throw new UnsupportedOperationException();
}
public ListIterator<E> listIterator()   {return listIterator(0);}
public ListIterator<E> listIterator(final int index) {
return new ListIterator<E>() {
ListIterator<? extends E> i = list.listIterator(index);
public boolean hasNext()     {return i.hasNext();}
public E next()          {return i.next();}
public boolean hasPrevious() {return i.hasPrevious();}
public E previous()      {return i.previous();}
public int nextIndex()       {return i.nextIndex();}
public int previousIndex()   {return i.previousIndex();}
public void remove() {
throw new UnsupportedOperationException();
}
public void set(E e) {
throw new UnsupportedOperationException();
}
public void add(E e) {
throw new UnsupportedOperationException();
}
};
}

OriginalL'auteur duffymo

Ces points de vue ne sera pas de retour vous avez vraiment thread-safe collections. Il y a toujours la possibilité que quelqu'un va modifier la sauvegarde de la collection, ou les éléments dans la collection.

Pour résoudre ce problème, vous devez utiliser immuable collections et immuable éléments. Ensuite, le fil de sécurité se produit.

Clojure contient de telles immuable (ou persistant) collections.

Mettre simplement en ajoutant ou en retirant des éléments nouveaux renvoie une nouvelle collection, qui, en général, ne réutilisation de grandes parties de l'ancienne collection grâce à l'utilisation intelligente de Trie-type de structures de données.

Sur leur propre, ce sont un mauvais ajustement pour l'utilisation dans droit en Java.

Pure4j est une tentative de port de ces (et l'immuable/valeur basée sur le style préconisé par Clojure) pour le langage Java. Il pourrait être ce que vous êtes après.

Avertissement: je suis le développeur de Pure4J

OriginalL'auteur Rob Moffat