LockSupport Classe

Référence

Définition

Espace de noms:: Java.Util.Concurrent.Locks

Assembly:: Mono.Android.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation.

[Android.Runtime.Register("java/util/concurrent/locks/LockSupport", DoNotGenerateAcw=true)]
public class LockSupport : Java.Lang.Object

[<Android.Runtime.Register("java/util/concurrent/locks/LockSupport", DoNotGenerateAcw=true)>]
type LockSupport = class
    inherit Object

Héritage: Object

Object
LockSupport

Attributs: RegisterAttribute

Remarques

Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation.

Cette classe associe, à chaque thread qui l’utilise, un permis (au sens de la java.util.concurrent.Semaphore Semaphore classe). Un appel à park retournera immédiatement si le permis est disponible, le consommant dans le processus ; sinon, il>< peut</em> bloquer. Un appel pour unpark rendre le permis disponible, s’il n’était pas déjà disponible. (Contrairement aux sémaphores cependant, les permis ne s’accumulent pas. Il y en a au plus un.) L’utilisation fiable nécessite l’utilisation de variables volatiles (ou atomiques) pour contrôler le moment où parcer ou annuler le parcage. Les classements des appels à ces méthodes sont conservés par rapport aux accès aux variables volatiles, mais pas nécessairement aux accès aux variables non volatiles.

Les méthodes park et unpark fournissent des moyens efficaces de bloquer et de débloquer des threads qui ne rencontrent pas les problèmes qui provoquent les méthodes Thread.suspend dépréciées et Thread.resume d’être inutilisables à de telles fins : les courses entre un thread appelant park et un autre thread essayant unpark de préserver la durée de vie, en raison du permis. De plus, park retourne si le thread de l’appelant a été interrompu et que les versions de délai d’attente sont prises en charge. La park méthode peut également retourner à tout autre moment, pour « aucune raison », donc en général doit être appelée dans une boucle qui revérifie les conditions lors du retour. Dans ce sens park sert d’optimisation d’une « attente occupée » qui ne gaspille pas autant de temps en rotation, mais doit être jumelée avec un unpark pour être efficace.

Les trois formes de park chacune prennent également en charge un paramètre d’objet blocker . Cet objet est enregistré pendant que le thread est bloqué pour autoriser la surveillance et les outils de diagnostic à identifier les raisons pour lesquelles les threads sont bloqués. (Ces outils peuvent accéder aux bloqueurs à l’aide de la méthode #getBlocker(Thread).) L’utilisation de ces formulaires plutôt que les formulaires originaux sans ce paramètre est fortement encouragé. L’argument normal à fournir en tant qu’implémentation blocker de verrou est this.

Ces méthodes sont conçues pour être utilisées comme outils de création d’utilitaires de synchronisation de niveau supérieur et ne sont pas elles-mêmes utiles pour la plupart des applications de contrôle d’accès concurrentiel. La park méthode est conçue pour être utilisée uniquement dans les constructions du formulaire :

{@code
            while (!canProceed()) {
              // ensure request to unpark is visible to other threads
              ...
              LockSupport.park(this);
            }}

où aucune action par le thread qui publie une requête pour annuler le parcage, avant l’appel à park, implique le verrouillage ou le blocage. Étant donné qu’un seul permis est associé à chaque thread, les utilisations intermédiaires, y compris implicitement par le biais du chargement de parkclasses, peuvent entraîner un thread non répondu (un « perdu unpark »).

<b>Exemple d’utilisation.</b> Voici un croquis d’une classe de verrou non réentrant first-in-first-out :

{@code
            class FIFOMutex {
              private final AtomicBoolean locked = new AtomicBoolean(false);
              private final Queue<Thread> waiters
                = new ConcurrentLinkedQueue<>();

              public void lock() {
                boolean wasInterrupted = false;
                // publish current thread for unparkers
                waiters.add(Thread.currentThread());

                // Block while not first in queue or cannot acquire lock
                while (waiters.peek() != Thread.currentThread() ||
                       !locked.compareAndSet(false, true)) {
                  LockSupport.park(this);
                  // ignore interrupts while waiting
                  if (Thread.interrupted())
                    wasInterrupted = true;
                }

                waiters.remove();
                // ensure correct interrupt status on return
                if (wasInterrupted)
                  Thread.currentThread().interrupt();
              }

              public void unlock() {
                locked.set(false);
                LockSupport.unpark(waiters.peek());
              }

              static {
                // Reduce the risk of "lost unpark" due to classloading
                Class<?> ensureLoaded = LockSupport.class;
              }
            }}

Ajouté à la version 1.5.

Documentation Java pour java.util.concurrent.locks.LockSupport.

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

LockSupport(IntPtr, JniHandleOwnership)

Constructeur utilisé lors de la création de représentations managées d’objets JNI ; appelée par le runtime.

Propriétés

Class	Retourne la classe runtime de ce `Object`. (Hérité de Object)
Handle	Handle de l’instance Android sous-jacente. (Hérité de Object)
JniIdentityHashCode	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation. (Hérité de Object)
JniPeerMembers	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation.
PeerReference	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation. (Hérité de Object)
ThresholdClass	Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code.
ThresholdType	Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code.

Méthodes

Clone()	Crée et retourne une copie de cet objet. (Hérité de Object)
Dispose()	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation. (Hérité de Object)
Dispose(Boolean)	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation. (Hérité de Object)
Equals(Object)	Indique si un autre objet est « égal à » celui-ci. (Hérité de Object)
GetBlocker(Thread)	Renvoie l’objet bloqueur fourni à l’appel le plus récent d’une méthode de parc qui n’a pas encore déblocée ou null si elle n’est pas bloquée.
GetHashCode()	Retourne une valeur de code de hachage pour l'objet. (Hérité de Object)
JavaFinalize()	Appelé par le garbage collector sur un objet lorsque le garbage collection détermine qu’il n’y a plus de références à l’objet. (Hérité de Object)
Notify()	Réveille un thread unique qui attend le moniteur de cet objet. (Hérité de Object)
NotifyAll()	Réveille tous les threads qui attendent le moniteur de cet objet. (Hérité de Object)
Park()	Désactive le thread actuel à des fins de planification de threads, sauf si l’autorisation est disponible.
Park(Object)	Désactive le thread actuel à des fins de planification de threads, sauf si l’autorisation est disponible.
ParkNanos(Int64)	Désactive le thread actuel à des fins de planification de threads, jusqu’au délai d’attente spécifié, sauf si l’autorisation est disponible.
ParkNanos(Object, Int64)	Désactive le thread actuel à des fins de planification de threads, jusqu’au délai d’attente spécifié, sauf si l’autorisation est disponible.
ParkUntil(Int64)	Désactive le thread actuel à des fins de planification de threads jusqu’à l’échéance spécifiée, sauf si le permis est disponible.
ParkUntil(Object, Int64)	Désactive le thread actuel à des fins de planification de threads jusqu’à l’échéance spécifiée, sauf si le permis est disponible.
SetCurrentBlocker(Object)	Définit l’objet à retourner par les appels du `#getBlocker getBlocker` thread actuel.
SetHandle(IntPtr, JniHandleOwnership)	Définit la propriété Handle. (Hérité de Object)
ToArray<T>()	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation. (Hérité de Object)
ToString()	Retourne une représentation de chaîne de l'objet. (Hérité de Object)
Unpark(Thread)	Rend disponible le permis pour le thread donné, s’il n’était pas déjà disponible.
UnregisterFromRuntime()	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation. (Hérité de Object)
Wait()	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti par em ou> <em>interrompu</em>.<> (Hérité de Object)
Wait(Int64, Int32)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)
Wait(Int64)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)

Implémentations d’interfaces explicites

IJavaPeerable.Disposed()	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation. (Hérité de Object)
IJavaPeerable.DisposeUnlessReferenced()	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation. (Hérité de Object)
IJavaPeerable.Finalized()	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation. (Hérité de Object)
IJavaPeerable.JniManagedPeerState	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation. (Hérité de Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation. (Hérité de Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation. (Hérité de Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation. (Hérité de Object)

Méthodes d’extension

JavaCast<TResult>(IJavaObject)	Effectue une conversion de type vérifiée par le runtime Android.
JavaCast<TResult>(IJavaObject)	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation.
GetJniTypeName(IJavaPeerable)	Primitives de blocage de thread de base pour la création de verrous et d’autres classes de synchronisation.

S’applique à

Partager via