util.concurrent.atomic.AtomicBoolean: référence pratique
util.concurrent.atomic.AtomicBoolean: référence pratique: AtomicBoolean contient un boolean modifiable atomiquement avec des effets mémoire allant de plain à volatile.
CKTIS / Java
Syntaxe, opérateurs et concepts de programmation. Trouvez une explication, explorez un exemple et reprenez votre apprentissage.
util.concurrent.atomic.AtomicBoolean: référence pratique: AtomicBoolean contient un boolean modifiable atomiquement avec des effets mémoire allant de plain à volatile.
AtomicInteger fournit des opérations atomiques sur une seule valeur int partagée entre plusieurs threads. Découvrez la lecture, l’écriture, l’incrémentation et les mises à jour conditionnelles, ainsi que les limites de l’atomicité.
AtomicLong contient une seule valeur long et permet des mises à jour atomiques partagées entre threads. Sa méthode incrementAndGet() augmente la valeur de un et renvoie le résultat mis à jour.
AtomicReference<V> fournit des opérations atomiques sur une seule référence. Découvrez les différences entre get(), le remplacement conditionnel avec compareAndSet() et le remplacement inconditionnel avec getAndSet(), ainsi que le rôle de l’identité des objets, plutôt que de l’égalité de leur contenu, dans la réussite d’un remplacement conditionnel.
LongAccumulator combine des valeurs long à l’aide d’une fonction fournie. Il prend en charge les mises à jour concurrentes, mais get() ne fournit pas d’instantané atomique de l’état pendant les mises à jour.
LongAdder accumule une somme de type long mise à jour par plusieurs threads. Il convient aux statistiques, mais sum() ne fournit pas d’instantané atomique et la remise à zéro exige de contrôler les mises à jour concurrentes.
BlockingQueue<E> permet l’échange sûr d’éléments entre threads, par exemple entre un producteur et un consommateur. Elle distingue les opérations qui n’attendent ni place ni élément, celles qui attendent, et les variantes avec délai maximal. L’exemple utilise une ArrayBlockingQueue de capacité 1.
util.concurrent.Callable: référence pratique: Callable<V> est une interface fonctionnelle pour une tâche sans argument qui renvoie V et peut lever Exception.
CompletableFuture<T> représente un résultat futur et permet d’enchaîner des étapes dépendantes sans bloquer après chacune d’elles. Découvrez les transformations, la composition, la combinaison de résultats, la gestion des erreurs et les délais d’attente dans Java SE 21.
util.concurrent.CompletionService: référence pratique: CompletionService<V> sépare la soumission des tâches de la récupération de leurs Future dans l’ordre d’achèvement.
util.concurrent.CompletionStage: référence pratique: CompletionStage<T> décrit une étape de calcul qui exécute une action ou calcule une valeur lorsqu’une autre étape s’achève.
ConcurrentHashMap permet à plusieurs threads d’utiliser en toute sécurité une map partagée. Les opérations atomiques sur une clé ne transforment toutefois pas une suite d’appels en transaction.
Découvrez ConcurrentLinkedQueue et ses méthodes add, isEmpty et poll pour ajouter des éléments, vérifier si la file est vide et récupérer des éléments en toute sécurité.
util.concurrent.CopyOnWriteArrayList: référence pratique: CopyOnWriteArrayList<E> est une liste thread-safe qui copie tout son tableau sous-jacent à chaque mutation.
CountDownLatch coordonne les threads : await() attend que les appels à countDown() ramènent le compteur à zéro. Il permet d’attendre un groupe d’opérations et garantit la visibilité des écritures antérieures.
CyclicBarrier synchronise un nombre fixe de participants aux limites de phases successives. L’appel à await() attend les autres ; une action facultative regroupe les résultats avant le début de la phase suivante.
java.util.concurrent.Executor accepte des tâches Runnable via execute. Il sépare la soumission d’une tâche de son mode d’exécution ; il ne garantit ni un thread distinct ni une exécution asynchrone.
java.util.concurrent.Executors fournit des méthodes de fabrique pour créer des exécuteurs de tâches. Executors.newFixedThreadPool limite le nombre de threads actifs, mais pas la taille de la file d’attente. Découvrez comment récupérer les résultats et fermer le pool avec Java SE 21.
ExecutorService sépare la soumission des tâches de la gestion de leur exécution. Découvrez submit, l’exécution groupée avec invokeAll et shutdown, ainsi que la différence entre demander l’arrêt et attendre la fin effective.
util.concurrent.Flow: référence pratique: Flow regroupe les interfaces Publisher, Subscriber, Subscription et Processor compatibles Reactive Streams avec contrôle de la demande.
Future<V> représente le résultat d’une tâche asynchrone. Future.get récupère le résultat en attendant si nécessaire, tandis que Future.isDone vérifie si la tâche est terminée, ce qui ne signifie pas forcément qu’elle a réussi.
LinkedBlockingQueue est une file FIFO thread-safe constituée de nœuds chaînés. Elle accepte une limite de capacité facultative et propose des opérations qui attendent une place libre ou un élément, ce qui la rend utile pour la communication entre producteurs et consommateurs.
Condition permet à un thread d’attendre un changement d’un état partagé protégé par un Lock. Découvrez await, awaitNanos, signal et signalAll, ainsi que l’importance de vérifier l’état dans une boucle.
L’interface java.util.concurrent.locks.Lock permet de contrôler explicitement le verrouillage. Découvrez la paire lock()/unlock(), le modèle sûr try/finally et un exemple où ReentrantLock protège un compteur partagé.