Startseite / Collections / Von veralteten synchronisierten Collections zu modernen Alternativen
Collections Fortgeschritten

Von veralteten synchronisierten Collections zu modernen Alternativen

Vector und Hashtable durch Collections ersetzen, die den tatsächlichen Anforderungen an Veränderbarkeit und Nebenläufigkeit entsprechen.

Collections Concurrency
Code-Vergleich
✕ Legacy synchronized collection 
Hashtable<String, Session> sessions = new Hashtable<>();
sessions.put(id, session);
✓ Concurrent Collections API 
ConcurrentMap<String, Session> sessions = new ConcurrentHashMap<>();
sessions.put(id, session);
Problem mit diesem Code entdeckt? Sag uns Bescheid.
Warum der moderne Weg gewinnt
🎯

Bewusste Nebenläufigkeit

Der gewählte Typ dokumentiert, ob eine gemeinsame Nutzung vorgesehen ist.

⚡

Bessere Skalierbarkeit

ConcurrentHashMap vermeidet bei normalen Zugriffen eine einzige Sperre für die gesamte Tabelle.

🧩

Moderne APIs

Funktioniert nahtlos mit aktuellen Collection- und ConcurrentMap-Operationen.

Alter Ansatz
Hashtable
Moderner Ansatz
ConcurrentHashMap
Seit JDK
5
Schwierigkeitsgrad
Fortgeschritten
JDK-Unterstützung
Von veralteten synchronisierten Collections zu modernen Alternativen
Verfügbar

Weitgehend verfügbar seit JDK 5 (September 2004)

Wie es funktioniert

Vector und Hashtable synchronisieren jede Operation über veraltete APIs. Moderner Code sollte für Thread-lokale Daten normalerweise ArrayList oder HashMap und bei gemeinsam genutzten Mutationen speziell dafür entwickelte nebenläufige Collections verwenden.

Zugehörige Dokumentation
ConcurrentHashMap ↗ ConcurrentMap ↗
Beweis
Beweisquelle ansehen ↗
Verwandte Muster
Collections Einsteiger

Immutable map creation

Java 8
Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
map = Collections.unmodifiableMap(map);
Java 9+
Map<String, Integer> map =
    Map.of("a", 1, "b", 2, "c", 3);
Hover für Modernes ➜
JDK 9+ →
Collections Einsteiger

Copying collections immutably

Java 8
List<String> copy =
    Collections.unmodifiableList(
        new ArrayList<>(original)
    );
Java 10+
List<String> copy =
    List.copyOf(original);
Hover für Modernes ➜
JDK 10+ →
Concurrency Experte

Lock-free lazy initialization

Java 8
class Config {
    private static volatile Config inst;
    static Config get() {
        if (inst == null) {
            synchronized (Config.class) {
                if (inst == null)
                    inst = load();
            }
        }
        return inst;
    }
}
Java 25 (Preview)
class Config {
    private static final
        StableValue<Config> INST =
            StableValue.of(Config::load);

    static Config get() {
        return INST.get();
    }
}
Hover für Modernes ➜
JDK 25+ →