Accueil / Collections / Des collections synchronisées historiques aux alternatives modernes
Collections Intermédiaire

Des collections synchronisées historiques aux alternatives modernes

Remplacez Vector et Hashtable par des collections adaptées aux besoins réels de mutabilité et de concurrence.

Collections Concurrency
Comparaison de Code
✕ 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);
Un problème avec ce code ? Dites-le nous.
Pourquoi la méthode moderne gagne
🎯

Concurrence explicite

Le type choisi indique si le partage est prévu.

⚡

Meilleure évolutivité

ConcurrentHashMap évite un verrou unique sur toute la table pour les accès ordinaires.

🧩

APIs modernes

S'intègre naturellement aux opérations actuelles sur les collections et les maps concurrentes.

Ancienne Approche
Hashtable
Approche Moderne
ConcurrentHashMap
Depuis JDK
5
Difficulté
Intermédiaire
Support JDK
Des collections synchronisées historiques aux alternatives modernes
Disponible

Largement disponible depuis JDK 5 (septembre 2004)

Comment ça fonctionne

Vector et Hashtable synchronisent chaque opération au moyen d'APIs historiques. Le code moderne devrait normalement utiliser ArrayList ou HashMap pour les données confinées à un thread, et des collections concurrentes spécialisées lorsqu'une mutation partagée est nécessaire.

Documentation Associée
ConcurrentHashMap ↗ ConcurrentMap ↗
Preuve
Voir la preuve source ↗
Patterns associés
Collections Débutant

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);
Survolez pour voir le moderne ➜
JDK 9+ →
Collections Débutant

Copying collections immutably

Java 8
List<String> copy =
    Collections.unmodifiableList(
        new ArrayList<>(original)
    );
Java 10+
List<String> copy =
    List.copyOf(original);
Survolez pour voir le moderne ➜
JDK 10+ →
Concurrency Avancé

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();
    }
}
Survolez pour voir le moderne ➜
JDK 25+ →