Wie, um wieder eine thread-sichere/immutable Collection in Java?

In das Projekt, das ich bin-Kodierung, die ich brauche, um wieder eine thread-sichere und unveränderliche Ansicht von einer Funktion. Allerdings bin ich nicht sicher. Da synchronizedList und unmodifiableList nur zurück, Blick auf eine Liste, ich weiß nicht, ob

Collections.synchronizedList(Collections.unmodifiableList(this.data));

würde den trick tun.

Könnte mir jemand sagen ob dies korrekt ist, und falls nicht, gibt es irgendwelche Situationen, dies würde wahrscheinlich zu scheitern?

Vielen Dank für alle inputs!

InformationsquelleAutor Ziyao Wei | 2011-07-12
  1. 13

    Ich finde, dass dies eine echte Lücke in der JDK. Zum Glück, ein team, über eine Google-led von Java Collections designer Joshua Bloch, haben eine Bibliothek enthält wirklich unveränderlich Sammlungen.

    ImmutableList in allem ist die Umsetzung, die Sie suchen. Hier ist eine schnelle Skizze einige der Eigenschaften der Guave ist ImmutableCollections.

    • +1 Ray, können Sie einen link oder ausführlich, was Sie bedeuten, eine echte Lücke im JDK, ist dies bis JDK 6 und 7?
    • Ich weiß nicht, der eine solche Ergänzung im JDK 7; ich kenne keine wirklich unveränderliche Liste in JDK 6.
    • Sie können das gleiche Ergebnis erhalten, obwohl, indem Sie eine Kopie der original-Liste und die Rückkehr eine unveränderliche Sicht auf die Kopie. So ist es im Grunde speichert nur eine Zeile code, aber dann, wenn man bereits mit Guave, warum schreiben Sie eine extra Zeile?
    • ja und Nein. Du hast Recht, dass die unveränderliche Sicht auf ein ausrangiertes Exemplar wäre wirklich unveränderlich. Aber, dann, angenommen, Sie sind die Verbraucher von dieser Liste. Sie wissen nicht, wenn der Hersteller beibehalten hat, die Bearbeitbare Liste oder nicht. So haben Sie, um eine defensive Kopie Ihrer selbst, die hat ein gewisser Aufwand verbunden. Wenn Sie mit einer Liste könnte garantieren, dass es konnte nicht modifiziert werden durch irgendwelche Mittel, die der Programmierer sicher sein könnten, dass dieser Schritt vermieden werden könnte. Als eine Angelegenheit von der Tat, wenn Sie versuchen, eine defensive Kopie von Guave ist ImmutableList, es wird Sie wieder die ursprüngliche Instanz.
    • Es gibt einen Beweis Guave Unveränderlich Sammlung ist WIRKLICH thread-safe? Ich bin noch nicht ganz sicher. Die Frage ist nicht, über gleichzeitige änderungen, aber über das Java-memory-Modell Parallelität Effekte.
    InformationsquelleAutor Ray
  2. 5

    Ich denke unveränderbar ist ausreichend. Sie können es nicht zu schreiben, das ist, was verursacht Probleme für multi-threaded-Zugriff. Es ist read-only, so dass der zusätzliche Schritt der Synchronisierung scheint überflüssig für mich.

    Beste heraus zu überprüfen den Quellcode, wenn es sind Fragen wie diese. Sieht aus wie es gibt ein 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();
            }
    };
}
    • Ist aber nicht unveränderbar, nur zurück, eine Ansicht, der thread, Holen Sie sich diese Ansicht nicht ändern die Liste durch? Oder vielleicht bin ich zu interpretieren es falsch?
    • Der Verbraucher wäre nicht in der Lage, zum ändern der Liste, aber die original-Liste kann geändert werden, wenn es aufbewahrt wird.
    • Das ist richtig, solange niemand ändert das "original" (ausgepackt) Sammlung. Es ist eine gute Idee, diese zu begrenzen, um Sammlungen, die Sie konstruiert sich selbst. Verlieren Sie Ihre Referenz zu der ursprünglichen, sobald Sie wickeln Sie es mit unmodifiable ist auch eine gute Idee. Sicherer noch ist die Verwendung der unveränderliche Sammlungen erwähnt in Ray ' s Antwort, da es keine veränderliche Sammlung versehentlich austreten kann.
    InformationsquelleAutor duffymo
  3. 4
    Collections.unmodifiableList(this.data)

    Tun, als wird es wieder ein Blick. Jede änderung versucht auf diese Ansicht wird im Ergebnis UnsupportedOperationException geworfen. Unten sind ein Auszug von Collections#unmodifiableList Dokumentation.

    Gibt eine unveränderliche Sicht auf die angegebene Liste. Diese Methode erlaubt es, Module für Benutzer mit "nur Lesen"-Zugriff auf interne Listen. Abfrage-Operationen auf der zurückgegebenen Liste "durch zu Lesen", um die angegebene Liste, und versuche, ändern Sie den zurückgegebenen Liste, ob direkt oder über den iterator Ergebnis in einer UnsupportedOperationException.

    ......

    java 8 java.util.Sammlungen javadoc

    InformationsquelleAutor Awan Biru
  4. 0

    Diese Ansichten nicht zurückkehren, Sie wirklich thread-safe collections. Es besteht immer die Möglichkeit, dass jemand " ändern Sie entweder die backing-Sammlung, oder die Elemente innerhalb der Sammlung.

    Um dieses Problem zu lösen, müssen Sie die unveränderliche Sammlungen und unveränderliche Elemente. Dann, thread-Sicherheit als Folge passiert.

    Clojure enthält unveränderliche (oder persistent) Sammlungen.

    Setzen Sie einfach, hinzufügen oder entfernen von neuen Elementen gibt es eine neue Kollektion, die im Allgemeinen hat Wiederverwendung großer Teile der alten Sammlung durch geschickten Einsatz von Trie-Typ Datenstrukturen.

    Auf Ihre eigenen, diese sind eine schlechte Passform für die Verwendung in geraden Java.

    Pure4j ist ein Versuch, auf diesen port (und die unveränderliche/value based Stil befürwortet, Clojure), um die Java-Sprache. Es könnte sein was Sie suchen.

    Disclaimer: ich bin der Entwickler von Pure4J

    InformationsquelleAutor Rob Moffat
Schreibe einen Kommentar