ConcurrentHashMap Classe

Définition

[Android.Runtime.Register("java/util/concurrent/ConcurrentHashMap", DoNotGenerateAcw=true)]
[Java.Interop.JavaTypeParameters(new System.String[] { "K", "V" })]
public class ConcurrentHashMap : Java.Util.AbstractMap, IDisposable, Java.Interop.IJavaPeerable, Java.IO.ISerializable, Java.Util.Concurrent.IConcurrentMap

[<Android.Runtime.Register("java/util/concurrent/ConcurrentHashMap", DoNotGenerateAcw=true)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "K", "V" })>]
type ConcurrentHashMap = class
    inherit AbstractMap
    interface ISerializable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable
    interface IConcurrentMap
    interface IMap

Héritage

Object

Object

AbstractMap

ConcurrentHashMap

Attributs

RegisterAttribute JavaTypeParametersAttribute

Implémente

IJavaObject IJavaPeerable ISerializable IConcurrentMap IMap IDisposable

Remarques

Table de hachage prenant en charge la concurrence complète des récupérations et une concurrence attendue élevée pour les mises à jour. Cette classe obéit à la même spécification fonctionnelle que java.util.Hashtable, et inclut des versions de méthodes correspondant à chaque méthode de Hashtable. Toutefois, même si toutes les opérations sont thread-safe, les opérations de récupération n’impliquent <>pas</em> verrouillage, et il n’y a>< pas</em> de prise en charge du verrouillage de la table entière d’une manière qui empêche tout accès. Cette classe est entièrement interopérable avec Hashtable les programmes qui s’appuient sur sa sécurité de thread, mais pas sur ses détails de synchronisation.

Les opérations de récupération (y compris get) ne bloquent généralement pas, donc peuvent chevaucher les opérations de mise à jour (y compris put et remove). Les récupérations reflètent les résultats des dernières <opérations de mise à jour em>terminées</em> qui se tiennent à leur apparition. (Plus formellement, une opération de mise à jour pour une clé donnée porte une <relation em>se produit-before</em> avec une récupération (non null) pour cette clé signalant la valeur mise à jour.) Pour les opérations d’agrégation telles que putAll et clear, les récupérations simultanées peuvent refléter l’insertion ou la suppression de certaines entrées uniquement. De même, les itérateurs, les fractionneurs et les énumérations retournent des éléments reflétant l’état de la table de hachage à un moment donné ou depuis la création de l’itérateur/énumération. Ils ne lèvent <>pas</em> .java.util.ConcurrentModificationException ConcurrentModificationException Toutefois, les itérateurs sont conçus pour être utilisés par un seul thread à la fois. N’oubliez pas que les résultats des méthodes d’état d’agrégation, y compris size, isEmptyet containsValue sont généralement utiles uniquement lorsqu’une carte ne subit pas de mises à jour simultanées dans d’autres threads. Dans le cas contraire, les résultats de ces méthodes reflètent les états temporaires qui peuvent être adéquats à des fins de surveillance ou d’estimation, mais pas pour le contrôle du programme.

La table est développée dynamiquement lorsqu’il y a trop de collisions (c’est-à-dire des clés qui ont des codes de hachage distincts, mais qui appartiennent au même modulo de l’emplacement de la taille de la table), avec l’effet moyen attendu de maintenir environ deux compartiments par mappage (correspondant à un seuil de facteur de charge de 0,75 pour le redimensionnement). Il peut y avoir beaucoup d’écarts autour de cette moyenne, car les mappages sont ajoutés et supprimés, mais globalement, cela maintient un compromis de temps/espace couramment accepté pour les tables de hachage. Toutefois, le redimensionnement de cette table de hachage ou tout autre type de table de hachage peut être une opération relativement lente. Dans la mesure du possible, il est judicieux de fournir une estimation de taille en tant qu’argument de constructeur facultatif initialCapacity . Un argument de constructeur facultatif loadFactor supplémentaire fournit un moyen supplémentaire de personnaliser la capacité de table initiale en spécifiant la densité de table à utiliser pour calculer la quantité d’espace à allouer pour le nombre d’éléments donné. En outre, pour la compatibilité avec les versions précédentes de cette classe, les constructeurs peuvent éventuellement spécifier un indicateur supplémentaire concurrencyLevel pour le dimensionnement interne. Notez que l’utilisation de nombreuses clés avec exactement la même hashCode() façon est un moyen sûr de ralentir les performances de n’importe quelle table de hachage. Pour améliorater l’impact, lorsque les clés sont Comparable, cette classe peut utiliser l’ordre de comparaison entre les clés pour aider à rompre les liens.

Une Set projection d’un ConcurrentHashMap peut être créée (à l’aide #newKeySet() ou #newKeySet(int)) ou vue (en utilisant #keySet(Object) quand seules les clés sont intéressantes, et les valeurs mappées ne sont peut-être pas utilisées ou toutes prennent la même valeur de mappage.

Un ConcurrentHashMap peut être utilisé comme carte de fréquence évolutive (une forme d’histogramme ou de multiset) à l’aide java.util.concurrent.atomic.LongAdder de valeurs et d’initialisation via #computeIfAbsent computeIfAbsent. Par exemple, pour ajouter un nombre à un ConcurrentHashMap<String,LongAdder> freqs, vous pouvez utiliser freqs.computeIfAbsent(key, k -> new LongAdder()).increment();

Cette classe et ses vues et itérateurs implémentent toutes les <méthodes em>optional</em> des Map interfaces.Iterator

Comme Hashtable mais contrairement HashMapà , cette classe n’autorise <null>pas</em> à être utilisée comme clé ou valeur.

ConcurrentHashMaps prend en charge un ensemble d’opérations en bloc séquentielles et parallèles qui, contrairement à la plupart des Stream méthodes, sont conçues pour être appliquées en toute sécurité, et souvent sensiblement, même avec des cartes mises à jour simultanément par d’autres threads ; par exemple, lors de l’informatique d’un résumé des valeurs dans un registre partagé. Il existe trois types d’opération, chacun avec quatre formulaires, acceptant des fonctions avec des clés, des valeurs, des entrées et des paires (clé, valeur) en tant qu’arguments et/ou valeurs de retour. Étant donné que les éléments d’un ConcurrentHashMap ne sont pas classés d’une manière particulière et peuvent être traités dans des ordres différents dans des exécutions parallèles différentes, la justesse des fonctions fournies ne doit pas dépendre d’un ordre ou d’autres objets ou valeurs susceptibles de changer temporairement pendant que le calcul est en cours ; et à l’exception des actions forEach, doit idéalement être sans effet secondaire. Les opérations en bloc sur Map.Entry les objets ne prennent pas en charge la méthode setValue.

<ul><li>forEach : effectue une action donnée sur chaque élément. Un formulaire variant applique une transformation donnée sur chaque élément avant d’effectuer l’action.

<recherche li>: retourne le premier résultat non null disponible de l’application d’une fonction donnée sur chaque élément ; ignorer la recherche supplémentaire lorsqu’un résultat est trouvé.

<li>reduce : accumule chaque élément. La fonction de réduction fournie ne peut pas compter sur l’ordre (plus formellement, il doit être à la fois associatif et commutatif). Il existe cinq variantes :

<ul>

<li>Plain réductions. (Il n’existe pas de forme de cette méthode pour les arguments de fonction (clé, valeur), car il n’existe aucun type de retour correspondant.)

<réductions mappées>qui accumulent les résultats d’une fonction donnée appliquée à chaque élément.

<li>Réductions aux doubles scalaires, longs et ints, à l’aide d’une valeur de base donnée.

</ul></ul>

Ces opérations en bloc acceptent un parallelismThreshold argument. Les méthodes se poursuivent de façon séquentielle si la taille actuelle de la carte est estimée à inférieure au seuil donné. L’utilisation d’une valeur de suppression de Long.MAX_VALUE tout parallélisme. Utilisation d’une valeur de résultats dans 1 le parallélisme maximal en partitionnant en suffisamment de tâches subordonnées pour utiliser entièrement celui ForkJoinPool#commonPool() utilisé pour tous les calculs parallèles. Normalement, vous choisissez initialement l’une de ces valeurs extrêmes, puis mesurez les performances de l’utilisation de valeurs entre les valeurs qui compromissaient la surcharge par rapport au débit.

Les propriétés d’accès concurrentiel des opérations en bloc suivent celles de ConcurrentHashMap : tout résultat non null retourné par get(key) les méthodes d’accès associées porte une relation se produit avant l’insertion ou la mise à jour associée. Le résultat d’une opération en bloc reflète la composition de ces relations par élément (mais n’est pas nécessairement atomique par rapport à la carte dans son ensemble, sauf si elle est d’une certaine façon connue pour être quiescente). À l’inverse, étant donné que les clés et les valeurs de la carte ne sont jamais null, null sert d’indicateur atomique fiable de l’absence actuelle de résultat. Pour conserver cette propriété, null sert de base implicite pour toutes les opérations de réduction non scalaires. Pour les versions doubles, longues et int, la base doit être celle qui, lorsqu’elle est combinée à une autre valeur, retourne cette autre valeur (plus formellement, il doit s’agir de l’élément d’identité pour la réduction). La plupart des réductions courantes ont ces propriétés ; par exemple, le calcul d’une somme avec la base 0 ou un minimum avec des MAX_VALUE de base.

Les fonctions de recherche et de transformation fournies en tant qu’arguments doivent également retourner null pour indiquer l’absence de résultat (auquel cas elle n’est pas utilisée). Dans le cas de réductions mappées, cela permet également aux transformations de servir de filtres, de retourner null (ou, dans le cas de spécialisations primitives, la base de l’identité) si l’élément ne doit pas être combiné. Vous pouvez créer des transformations et des filtrages composés en les composant vous-même sous cette règle « Null signifie qu’il n’y a rien maintenant » avant de les utiliser dans les opérations de recherche ou de réduction.

Les méthodes acceptant et/ou retournant des arguments Entrée conservent des associations clé-valeur. Ils peuvent être utiles par exemple lors de la recherche de la clé pour la plus grande valeur. Notez que les arguments d’entrée « brut » peuvent être fournis à l’aide new AbstractMap.SimpleEntry(k,v)de .

Les opérations en bloc peuvent se terminer brusquement, lève une exception rencontrée dans l’application d’une fonction fournie. N’oubliez pas que lors de la gestion de telles exceptions que d’autres fonctions en cours d’exécution simultanée pouvaient également avoir levée des exceptions, ou si la première exception n’avait pas eu lieu.

Les vitesses de mise en parallèle par rapport aux formulaires séquentiels sont courantes, mais pas garanties. Les opérations parallèles impliquant de courtes fonctions sur de petites cartes peuvent s’exécuter plus lentement que les formulaires séquentiels si le travail sous-jacent pour paralléliser le calcul est plus coûteux que le calcul lui-même. De même, la parallélisation peut ne pas conduire à un parallélisme réel si tous les processeurs effectuent des tâches non liées.

Tous les arguments de toutes les méthodes de tâche doivent être non null.

Cette classe est membre de Java Collections Framework.

Ajouté à la version 1.5.

Documentation Java pour java.util.concurrent.ConcurrentHashMap.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

Constructeurs

Propriétés

Méthodes

Implémentations d’interfaces explicites

Méthodes d’extension

S’applique à