Contenu du cours

Multithreading en Java

1. Notions de Base du Multithreading

Qu'est-ce que le Multithreading Différence Entre le Multithreading et le Monothreading Threads en Java Synchronisation des Threads Performance et Défis Atomicité Tâche de Multithreading

2. Collections Synchronisées

Collections avec Support Multithreading API de Flux Parallèle BlockingQueue et Ses Implémentations Défi BlockingQueue ConcurrentMap et Ses Implémentations Défi ConcurrentMap Collection Copy-On-Write Exemples d'Utilisation des Méthodes de Collections

3. Mécanismes de Synchronisation de Haut Niveau

Verrou et Condition Défi Verrou et Condition Sémaphore et Barrière Défi Sémaphore Variables Atomiques Exécuteurs et Pool de Threads Défi Exécuteurs

4. Meilleures Pratiques de Multithreading

Producteur-Consommateur ForkJoinPool Défi ForkJoinPool ThreadLocal Principes de Base de la Programmation Asynchrone CompletableFuture Défi CompletableFuture Résumé Multithreading

Exemples d'Utilisation des Méthodes de Collections

Remarque

Aujourd'hui, nous examinerons principalement les méthodes qui aident à 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.

Main


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

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

Main


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

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

Main


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

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

Main


              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 mappages que la carte spécifiée.

Main


              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): Renvoie un ensemble immuable contenant les mêmes éléments que l'ensemble spécifié.

Main


              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 alors la différence entre créer des collections synchronisées par des implémentations normales (celles discutées dans les chapitres précédents) et utiliser les méthodes de Collections ?

Examinons la différence en utilisant une collection Map comme exemple

Différences entre l'utilisation de ConcurrentHashMap et synchronizedMap()

ConcurrentHashMap utilise une méthode avancée connue sous le nom de 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 à travers des segments différents de la map, améliorant ainsi la concurrence et la performance.

La méthode synchronizedMap() enveloppe la carte originale 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 bloqueront pas mutuellement. Cependant, si un bucket est accédé par 2 threads, l'un d'eux devra attendre. D'autre part, si la collection est créée via synchronizedMap(), seul 1 thread aura accès à tous les buckets, et l'ensemble de la carte est bloqué.

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

Aussi dans Collections, il existe d'autres méthodes 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 couramment utilisées. Les collections synchronisées créées via les méthodes Collections sont utiles pour la sécurité des threads, mais pour des tâches multithread plus complexes, il est préférable d'utiliser des collections du package java.util.concurrent.

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

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

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

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 8

Multithreading en Java

Exemples d'Utilisation des Méthodes de Collections

Méthodes de Collections

Différences entre l'utilisation de ConcurrentHashMap et synchronizedMap()

Aussi dans Collections, il existe d'autres méthodes pour un travail pratique avec les collections :

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

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

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

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