Home / Collections / Dalle collezioni sincronizzate legacy alle alternative moderne
Collections Intermedio

Dalle collezioni sincronizzate legacy alle alternative moderne

Sostituisci Vector e Hashtable con collezioni scelte in base alle effettive esigenze di mutabilità e concorrenza.

Collections Concurrency
Confronto Codice
✕ 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);
Vedi un problema con questo codice? Faccelo sapere.
Perché vince l'approccio moderno
🎯

Concorrenza intenzionale

Il tipo scelto documenta se è prevista la condivisione.

⚡

Migliore scalabilità

ConcurrentHashMap evita un unico lock sull'intera tabella per gli accessi normali.

🧩

API moderne

Funziona naturalmente con le attuali operazioni su collezioni e mappe concorrenti.

Approccio Vecchio
Hashtable
Approccio Moderno
ConcurrentHashMap
Dal JDK
5
Difficoltà
Intermedio
Supporto JDK
Dalle collezioni sincronizzate legacy alle alternative moderne
Disponibile

Ampiamente disponibile dal JDK 5 (settembre 2004)

Come funziona

Vector e Hashtable sincronizzano ogni operazione tramite API legacy. Il codice moderno dovrebbe normalmente usare ArrayList o HashMap per dati confinati a un thread e collezioni concorrenti dedicate quando è necessaria una mutazione condivisa.

Documentazione Correlata
ConcurrentHashMap ↗ ConcurrentMap ↗
Prova
Vedi sorgente di prova ↗
Pattern correlati
Collections Principiante

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);
Passa il mouse per vedere il moderno ➜
JDK 9+ →
Collections Principiante

Copying collections immutably

Java 8
List<String> copy =
    Collections.unmodifiableList(
        new ArrayList<>(original)
    );
Java 10+
List<String> copy =
    List.copyOf(original);
Passa il mouse per vedere il moderno ➜
JDK 10+ →
Concurrency Avanzato

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();
    }
}
Passa il mouse per vedere il moderno ➜
JDK 25+ →