Note

Aujourd'hui, nous allons principalement examiner les méthodes qui permettent de créer des collections thread-safe.

Méthodes de Collections

Voici quelques méthodes importantes fournies par la classe pour créer des collections Collections synchronisées :

synchronizedList(List<T> list): Retourne une liste synchronisée (thread-safe) qui respecte le même contrat que la liste passée en paramètre.

Main.java


              1
            
List<Object> listSync = Collections.synchronizedList(new ArrayList<>());

synchronizedSet(Set<T> set): Retourne un ensemble synchronisé (thread-safe) qui respecte le même contrat que l'ensemble passé en paramètre.

Main.java


              1
            
Set<Object> setSync = Collections.synchronizedSet(new HashSet<>());

synchronizedMap(Map<K, V> m) : Retourne une carte synchronisée (thread-safe) qui prend en charge le même contrat que la carte passée en paramètre.

Main.java


              1
            
Map<Object, Object> mapSync = Collections.synchronizedMap(new HashMap<>());

unmodifiableList(List<? extends T> list) : Renvoie une liste immuable contenant les mêmes éléments que la liste spécifiée.

Main.java


              123456789101112131415
            
package com.example;

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {

        List<Integer> unmodifiableList = Collections.unmodifiableList(new ArrayList<>(List.of(1,2,3)));

        System.out.println(unmodifiableList); // output [1,2,3]
        unmodifiableList.add(4); // throw exception `UnsupportedOperationException`
    }
}

unmodifiableMap(Map<? extends K, ? extends V> m) : Renvoie une carte immuable contenant les mêmes associations que la carte spécifiée.

Main.java


              12345678910111213
            
package com.example;

import java.util.Collections;
import java.util.Map;
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {

        Map<Integer, Integer> unmodifiableMap = Collections.unmodifiableMap(new HashMap<>());
        unmodifiableMap.put(1, 2); // exception `UnsupportedOperationException`
    }
}

unmodifiableSet(Set<? extends T> set) : Retourne un ensemble non modifiable contenant les mêmes éléments que l’ensemble spécifié.

Main.java


              12345678910111213
            
package com.example;

import java.util.Collections;
import java.util.Set;
import java.util.HashSet;

public class Main {
    public static void main(String[] args) {

        Set<Integer> unmodifiableSet = Collections.unmodifiableSet(new HashSet<>());
        unmodifiableSet.add(4); // exception `UnsupportedOperationException`
    }
}

Quelle est donc la différence entre la création de collections synchronisées via les implémentations classiques (celles abordées dans les chapitres précédents) et l'utilisation des méthodes de Collections ?

Examinons la différence à l'aide d'un exemple avec une collection Map

Différences entre ConcurrentHashMap et synchronizedMap()

ConcurrentHashMap utilise une méthode avancée appelée partitionnement de verrou (lock splitting), qui divise la map en segments et synchronise les opérations uniquement au niveau du segment. Cette approche permet à plusieurs threads de lire et écrire simultanément des données dans différents segments de la map, améliorant ainsi la concurrence et les performances.

La méthode synchronizedMap() encapsule la map d'origine dans un objet proxy synchronisé. Toutes les méthodes de cet objet proxy sont synchronisées, garantissant la sécurité des threads. Cependant, cette approche peut réduire les performances dans un environnement multithread en raison de la fréquence élevée de verrouillage impliquée.

Par exemple, si ConcurrentHashMap écrit dans différents buckets, les threads ne se bloquent pas mutuellement. Cependant, si un bucket est accédé par 2 threads, l'un d'eux attendra. En revanche, si la collection est créée via synchronizedMap(), un seul thread aura accès à tous les buckets, et l'ensemble de la map est bloqué.

Cela signifie que tant qu'un thread n'a pas terminé son travail, les autres threads ne pourront pas accéder. En conséquence, les opérations dans ConcurrentHashMap sont simplement exécutées plus rapidement.

D'autres méthodes dans Collections pour un travail pratique avec les collections :

Remarque

La classe Collections fournit des méthodes pratiques pour travailler avec les collections en Java, simplifiant les opérations courantes. Les collections synchronisées créées via les méthodes de Collections sont utiles pour la sécurité des threads, mais pour des tâches multithread plus complexes, il est préférable d'utiliser les collections du package java.util.concurrent.

1. Quelle méthode de la classe Collections est utilisée pour créer une liste immuable ?

2. Laquelle des méthodes suivantes de la classe `Collections` retourne une map thread-safe ?

3. Quelle est la différence entre ConcurrentHashMap et synchronizedMap ?

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 8

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Suggested prompts:

What are some other useful methods provided by the Collections class?

Can you give examples of when to use synchronizedMap() vs ConcurrentHashMap?

How do unmodifiable collections work in practice?

Awesome!

Completion rate improved to 3.33

Glissez pour afficher le menu

Note

Aujourd'hui, nous allons principalement examiner les méthodes qui permettent de créer des collections thread-safe.

Méthodes de Collections

Voici quelques méthodes importantes fournies par la classe pour créer des collections Collections synchronisées :

synchronizedList(List<T> list): Retourne une liste synchronisée (thread-safe) qui respecte le même contrat que la liste passée en paramètre.

Main.java


              1
            
List<Object> listSync = Collections.synchronizedList(new ArrayList<>());

synchronizedSet(Set<T> set): Retourne un ensemble synchronisé (thread-safe) qui respecte le même contrat que l'ensemble passé en paramètre.

Main.java


              1
            
Set<Object> setSync = Collections.synchronizedSet(new HashSet<>());

synchronizedMap(Map<K, V> m) : Retourne une carte synchronisée (thread-safe) qui prend en charge le même contrat que la carte passée en paramètre.

Main.java


              1
            
Map<Object, Object> mapSync = Collections.synchronizedMap(new HashMap<>());

unmodifiableList(List<? extends T> list) : Renvoie une liste immuable contenant les mêmes éléments que la liste spécifiée.

Main.java


              123456789101112131415
            
package com.example;

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {

        List<Integer> unmodifiableList = Collections.unmodifiableList(new ArrayList<>(List.of(1,2,3)));

        System.out.println(unmodifiableList); // output [1,2,3]
        unmodifiableList.add(4); // throw exception `UnsupportedOperationException`
    }
}

unmodifiableMap(Map<? extends K, ? extends V> m) : Renvoie une carte immuable contenant les mêmes associations que la carte spécifiée.

Main.java


              12345678910111213
            
package com.example;

import java.util.Collections;
import java.util.Map;
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {

        Map<Integer, Integer> unmodifiableMap = Collections.unmodifiableMap(new HashMap<>());
        unmodifiableMap.put(1, 2); // exception `UnsupportedOperationException`
    }
}

unmodifiableSet(Set<? extends T> set) : Retourne un ensemble non modifiable contenant les mêmes éléments que l’ensemble spécifié.

Main.java


              12345678910111213
            
package com.example;

import java.util.Collections;
import java.util.Set;
import java.util.HashSet;

public class Main {
    public static void main(String[] args) {

        Set<Integer> unmodifiableSet = Collections.unmodifiableSet(new HashSet<>());
        unmodifiableSet.add(4); // exception `UnsupportedOperationException`
    }
}

Examinons la différence à l'aide d'un exemple avec une collection Map

Différences entre ConcurrentHashMap et synchronizedMap()

D'autres méthodes dans Collections pour un travail pratique avec les collections :

Remarque

1. Quelle méthode de la classe Collections est utilisée pour créer une liste immuable ?

2. Laquelle des méthodes suivantes de la classe `Collections` retourne une map thread-safe ?

3. Quelle est la différence entre ConcurrentHashMap et synchronizedMap ?

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 8

Exemples d'Utilisation des Méthodes de Collections

Méthodes de Collections

Différences entre ConcurrentHashMap et synchronizedMap()

D'autres méthodes dans Collections pour un travail pratique avec les collections :

1. Quelle méthode de la classe Collections est utilisée pour créer une liste immuable ?

2. Laquelle des méthodes suivantes de la classe `Collections` retourne une map thread-safe ?

3. Quelle est la différence entre ConcurrentHashMap et synchronizedMap ?

Awesome!

Exemples d'Utilisation des Méthodes de Collections

Méthodes de Collections

Différences entre ConcurrentHashMap et synchronizedMap()

D'autres méthodes dans Collections pour un travail pratique avec les collections :

1. Quelle méthode de la classe Collections est utilisée pour créer une liste immuable ?

2. Laquelle des méthodes suivantes de la classe `Collections` retourne une map thread-safe ?

3. Quelle est la différence entre ConcurrentHashMap et synchronizedMap ?

Exemples d'Utilisation des Méthodes de Collections

Méthodes de Collections

Différences entre ConcurrentHashMap et synchronizedMap()

D'autres méthodes dans Collections pour un travail pratique avec les collections :

1. Quelle méthode de la classe Collections est utilisée pour créer une liste immuable ?

2. Laquelle des méthodes suivantes de la classe Collections retourne une map thread-safe ?

3. Quelle est la différence entre ConcurrentHashMap et synchronizedMap ?

Awesome!

Exemples d'Utilisation des Méthodes de Collections

Méthodes de Collections

Différences entre ConcurrentHashMap et synchronizedMap()

D'autres méthodes dans Collections pour un travail pratique avec les collections :

1. Quelle méthode de la classe Collections est utilisée pour créer une liste immuable ?

2. Laquelle des méthodes suivantes de la classe Collections retourne une map thread-safe ?

3. Quelle est la différence entre ConcurrentHashMap et synchronizedMap ?

2. Laquelle des méthodes suivantes de la classe `Collections` retourne une map thread-safe ?

2. Laquelle des méthodes suivantes de la classe `Collections` retourne une map thread-safe ?