AbstractQueuedSynchronizer Classe
Définition
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.
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO).
[Android.Runtime.Register("java/util/concurrent/locks/AbstractQueuedSynchronizer", DoNotGenerateAcw=true)]
public abstract class AbstractQueuedSynchronizer : Java.Util.Concurrent.Locks.AbstractOwnableSynchronizer, IDisposable, Java.Interop.IJavaPeerable[<Android.Runtime.Register("java/util/concurrent/locks/AbstractQueuedSynchronizer", DoNotGenerateAcw=true)>]
type AbstractQueuedSynchronizer = class
inherit AbstractOwnableSynchronizer
interface ISerializable
interface IJavaObject
interface IDisposable
interface IJavaPeerable- Héritage
- Attributs
- Implémente
Remarques
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). Cette classe est conçue pour être une base utile pour la plupart des types de synchronisateurs qui s’appuient sur une valeur atomique int unique pour représenter l’état. Les sous-classes doivent définir les méthodes protégées qui modifient cet état et qui définissent ce que signifie cet état en termes d’acquisition ou de libération de cet objet. Compte tenu de ceux-ci, les autres méthodes de cette classe effectuent toutes les mécaniques de mise en file d’attente et de blocage. Les sous-classes peuvent conserver d’autres champs d’état, mais uniquement la valeur mise à jour atomiquement manipulée à int l’aide de méthodes #getState, #setState et #compareAndSetState est suivie en ce qui concerne la synchronisation.
Les sous-classes doivent être définies comme des classes d’assistance internes non publiques utilisées pour implémenter les propriétés de synchronisation de leur classe englobante. La classe AbstractQueuedSynchronizer n’implémente aucune interface de synchronisation. Au lieu de cela, il définit des méthodes telles que #acquireInterruptibly celles qui peuvent être appelées selon les verrous concrets et les synchronisateurs associés pour implémenter leurs méthodes publiques.
Cette classe prend en charge un mode em exclusif/em par défaut <et un <mode em>partagé</em>.><> Lorsqu’elle est acquise en mode exclusif, les tentatives d’acquisition par d’autres threads ne peuvent pas réussir. Le mode partagé acquiert par plusieurs threads peut (mais il n’est pas nécessaire) de réussir. Cette classe n’est pas " comprendre" ces différences sauf dans le sens mécanique que lorsqu’un mode partagé acquiert réussit, le fil d’attente suivant (s’il en existe) doit également déterminer s’il peut également acquérir. Les threads en attente dans les différents modes partagent la même file d’attente FIFO. En règle générale, les sous-classes d’implémentation ne prennent en charge qu’un seul de ces modes, mais les deux peuvent entrer en jeu par exemple dans un ReadWriteLock. Les sous-classes qui prennent uniquement en charge les modes exclusifs ou uniquement partagés n’ont pas besoin de définir les méthodes prenant en charge le mode inutilisé.
Cette classe définit une classe imbriquée ConditionObject qui peut être utilisée comme Condition implémentation par des sous-classes prenant en charge le mode exclusif pour lequel la méthode #isHeldExclusively indique si la synchronisation est exclusivement conservée par rapport au thread actuel, la méthode #release appelée avec la valeur actuelle #getState libère entièrement cet objet et #acquire, étant donné cette valeur d’état enregistrée, restaure finalement cet objet à son état acquis précédent. Aucune méthode ne AbstractQueuedSynchronizer crée une telle condition. Par conséquent, si cette contrainte ne peut pas être remplie, n’utilisez pas cette condition. Le comportement de ConditionObject dépend bien sûr de la sémantique de son implémentation du synchronisateur.
Cette classe fournit des méthodes d’inspection, d’instrumentation et de surveillance pour la file d’attente interne, ainsi que des méthodes similaires pour les objets de condition. Celles-ci peuvent être exportées comme vous le souhaitez dans des classes à l’aide d’une AbstractQueuedSynchronizer mécanique de synchronisation.
La sérialisation de cette classe stocke uniquement l’état de maintien de l’entier atomique sous-jacent, de sorte que les objets désérialisés ont des files d’attente de thread vides. Les sous-classes classiques nécessitant une sérialisabilité définissent une readObject méthode qui restaure ceci à un état initial connu lors de la désérialisation.
<Utilisation> h2</h2>
Pour utiliser cette classe comme base d’un synchronisateur, redéfinissez les méthodes suivantes, le cas échéant, en inspectant et/ou en modifiant l’état de synchronisation à l’aide #getState#setState , et/ou #compareAndSetState:
<ul><li>#tryAcquire<li><#tryReleaseli><#tryAcquireSharedli>#tryReleaseShared<li>#isHeldExclusively</ul>
Chacune de ces méthodes lève UnsupportedOperationExceptionpar défaut . Les implémentations de ces méthodes doivent être thread-safe en interne et doivent en général être courtes et non bloquées. La définition de ces méthodes est le <moyen pris en charge par em>uniquement</em> d’utiliser cette classe. Toutes les autres méthodes sont déclarées final parce qu’elles ne peuvent pas être variées indépendamment.
Vous pouvez également trouver les méthodes héritées d’utiles AbstractOwnableSynchronizer pour suivre le thread propriétaire d’un synchronisateur exclusif. Vous êtes encouragé à les utiliser : cela permet à la surveillance et aux outils de diagnostic d’aider les utilisateurs à déterminer les threads qui contiennent des verrous.
Même si cette classe est basée sur une file d’attente FIFO interne, elle n’applique pas automatiquement les stratégies d’acquisition FIFO. Le cœur de la synchronisation exclusive prend la forme suivante :
<em>Acquire:</em>
while (!tryAcquire(arg)) {
<em>enqueue thread if it is not already queued</em>;
<em>possibly block current thread</em>;
}
<em>Release:</em>
if (tryRelease(arg))
<em>unblock the first queued thread</em>;
(Le mode partagé est similaire, mais peut impliquer des signaux en cascade.)
Étant donné que les vérifications dans l’acquisition sont appelées avant la mise en file d’attente, un thread nouvellement acquis peut <em>barge</em> devant d’autres qui sont bloqués et mis en file d’attente. Toutefois, vous pouvez, si vous le souhaitez, définir tryAcquire et/ou tryAcquireShared désactiver le barging en appelant en interne une ou plusieurs des méthodes d’inspection, fournissant ainsi un>< ordre d’acquisition em fair</em> FIFO. En particulier, la plupart des synchronisateurs équitables peuvent définir tryAcquire pour retourner false si #hasQueuedPredecessors (une méthode spécifiquement conçue pour être utilisée par des synchronisateurs équitables) retourne true. D’autres variantes sont possibles.
Le débit et l’extensibilité sont généralement les plus élevés pour la stratégie de barging par défaut (également appelée <em greedy</em, <>em> renoncement</em>, et>< em convoy-avoidance</em>).> Bien que cela ne soit pas garanti pour être équitable ou sans faim, les threads mis en file d’attente antérieurs sont autorisés à être recontenés avant les threads mis en file d’attente ultérieurs, et chaque contention a une chance non biaisée de réussir sur les threads entrants. En outre, tandis que les acquisitions ne sont pas " spin" dans le sens habituel, ils peuvent effectuer plusieurs appels d’interspersés tryAcquire avec d’autres calculs avant de bloquer. Cela offre la plupart des avantages des spins lorsque la synchronisation exclusive n’est que brièvement détenue, sans la plupart des passifs quand ce n’est pas le cas. Si vous le souhaitez, vous pouvez augmenter cela en effectuant des appels précédents pour acquérir des méthodes avec des vérifications « fast-path », éventuellement pré-vérification #hasContended et/ou #hasQueuedThreads pour le faire uniquement si le synchronisateur est susceptible de ne pas être soutenu.
Cette classe fournit une base efficace et évolutive pour la synchronisation en partie en spécialisée dans sa gamme d’utilisation pour les synchronisateurs qui peuvent s’appuyer sur int les paramètres d’état, d’acquisition et de mise en production, ainsi qu’une file d’attente FIFO interne. Quand cela ne suffit pas, vous pouvez générer des synchronisateurs à partir d’un niveau inférieur à l’aide java.util.concurrent.atomic atomic de classes, de vos propres classes personnalisées java.util.Queue et LockSupport de la prise en charge des blocages.
<Exemples< d’utilisation h2>/h2>
Voici une classe de verrou d’exclusion mutuelle non réentrante qui utilise la valeur zéro pour représenter l’état déverrouillé et un pour représenter l’état verrouillé. Bien qu’un verrou non réentrant ne nécessite pas strictement l’enregistrement du thread propriétaire actuel, cette classe le fait de toute façon pour faciliter l’utilisation à surveiller. Il prend également en charge les conditions et expose certaines méthodes d’instrumentation :
{@code
class Mutex implements Lock, java.io.Serializable {
// Our internal helper class
private static class Sync extends AbstractQueuedSynchronizer {
// Acquires the lock if state is zero
public boolean tryAcquire(int acquires) {
assert acquires == 1; // Otherwise unused
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
// Releases the lock by setting state to zero
protected boolean tryRelease(int releases) {
assert releases == 1; // Otherwise unused
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
setExclusiveOwnerThread(null);
setState(0);
return true;
}
// Reports whether in locked state
public boolean isLocked() {
return getState() != 0;
}
public boolean isHeldExclusively() {
// a data race, but safe due to out-of-thin-air guarantees
return getExclusiveOwnerThread() == Thread.currentThread();
}
// Provides a Condition
public Condition newCondition() {
return new ConditionObject();
}
// Deserializes properly
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException {
s.defaultReadObject();
setState(0); // reset to unlocked state
}
}
// The sync object does all the hard work. We just forward to it.
private final Sync sync = new Sync();
public void lock() { sync.acquire(1); }
public boolean tryLock() { return sync.tryAcquire(1); }
public void unlock() { sync.release(1); }
public Condition newCondition() { return sync.newCondition(); }
public boolean isLocked() { return sync.isLocked(); }
public boolean isHeldByCurrentThread() {
return sync.isHeldExclusively();
}
public boolean hasQueuedThreads() {
return sync.hasQueuedThreads();
}
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
}}
Voici une classe de verrous qui est comme une java.util.concurrent.CountDownLatch CountDownLatch exception, sauf qu’elle ne nécessite qu’un seul signal feu. Étant donné qu’un verrou n’est pas exclusif, il utilise les shared méthodes d’acquisition et de mise en production.
{@code
class BooleanLatch {
private static class Sync extends AbstractQueuedSynchronizer {
boolean isSignalled() { return getState() != 0; }
protected int tryAcquireShared(int ignore) {
return isSignalled() ? 1 : -1;
}
protected boolean tryReleaseShared(int ignore) {
setState(1);
return true;
}
}
private final Sync sync = new Sync();
public boolean isSignalled() { return sync.isSignalled(); }
public void signal() { sync.releaseShared(1); }
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
}}
Ajouté à la version 1.5.
Documentation Java pour java.util.concurrent.locks.AbstractQueuedSynchronizer.
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
| Nom | Description |
|---|---|
| AbstractQueuedSynchronizer() |
Crée une |
| AbstractQueuedSynchronizer(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
| Nom | Description |
|---|---|
| Class |
Retourne la classe runtime de ce |
| ExclusiveOwnerThread |
Retourne le dernier jeu de threads par |
| ExclusiveQueuedThreads |
Retourne une collection contenant des threads qui peuvent attendre d’acquérir en mode exclusif. |
| FirstQueuedThread |
Retourne le premier thread (en attente la plus longue) dans la file d’attente, ou |
| Handle |
Handle de l’instance Android sous-jacente. (Hérité de Object) |
| HasContended |
Interroge si des threads ont jamais soutenu l’acquisition de ce synchronisateur ; autrement dit, si une méthode d’acquisition n’a jamais été bloquée. |
| HasQueuedPredecessors |
Interroge si des threads attendent d’acquérir plus longtemps que le thread actuel. |
| HasQueuedThreads |
Interroge si des threads attendent d’acquérir. |
| IsHeldExclusively |
Retourne |
| JniIdentityHashCode |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). (Hérité de Object) |
| JniPeerMembers |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). |
| PeerReference |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). (Hérité de Object) |
| QueuedThreads |
Retourne une collection contenant des threads qui peuvent attendre l’acquisition. |
| QueueLength |
Retourne une estimation du nombre de threads en attente d’acquisition. |
| SharedQueuedThreads |
Retourne une collection contenant des threads qui peuvent attendre l’acquisition en mode partagé. |
| State |
Retourne la valeur actuelle de l’état de synchronisation. -ou- Définit la valeur de l’état de synchronisation. |
| 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
| Nom | Description |
|---|---|
| Acquire(Int32) |
Acquiert en mode exclusif, ignorant les interruptions. |
| AcquireInterruptibly(Int32) |
Acquiert en mode exclusif, abandon en cas d’interruption. |
| AcquireShared(Int32) |
Acquiert en mode partagé, ignorant les interruptions. |
| AcquireSharedInterruptibly(Int32) |
Acquiert en mode partagé, abandon en cas d’interruption. |
| Clone() |
Crée et retourne une copie de cet objet. (Hérité de Object) |
| CompareAndSetState(Int32, Int32) |
Définit atomiquement l’état de synchronisation sur la valeur mise à jour donnée si la valeur d’état actuelle est égale à la valeur attendue. |
| Dispose() |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). (Hérité de Object) |
| Dispose(Boolean) |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). (Hérité de Object) |
| Equals(Object) |
Indique si un autre objet est « égal à » celui-ci. (Hérité de Object) |
| GetHashCode() |
Retourne une valeur de code de hachage pour l'objet. (Hérité de Object) |
| GetWaitingThreads(AbstractQueuedSynchronizer+ConditionObject) |
Retourne une collection contenant ces threads qui peuvent être en attente sur la condition donnée associée à ce synchronisateur. |
| GetWaitQueueLength(AbstractQueuedSynchronizer+ConditionObject) |
Retourne une estimation du nombre de threads en attente sur la condition donnée associée à ce synchronisateur. |
| HasWaiters(AbstractQueuedSynchronizer+ConditionObject) |
Interroge si des threads attendent la condition donnée associée à ce synchronisateur. |
| IsQueued(Thread) |
Retourne true si le thread donné est actuellement mis en file d’attente. |
| 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) |
| Owns(AbstractQueuedSynchronizer+ConditionObject) |
Interroge si conditionObject donné utilise ce synchronisateur comme verrou. |
| Release(Int32) |
Versions en mode exclusif. |
| ReleaseShared(Int32) |
Versions en mode partagé. |
| SetHandle(IntPtr, JniHandleOwnership) |
Définit la propriété Handle. (Hérité de Object) |
| ToArray<T>() |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). (Hérité de Object) |
| ToString() |
Retourne une représentation de chaîne de l'objet. (Hérité de Object) |
| TryAcquire(Int32) |
Tente d’acquérir en mode exclusif. |
| TryAcquireNanos(Int32, Int64) |
Tente d’acquérir en mode exclusif, d’abandon en cas d’interruption et d’échec si le délai d’expiration donné s’écoule. |
| TryAcquireShared(Int32) |
Tente d’acquérir en mode partagé. |
| TryAcquireSharedNanos(Int32, Int64) |
Tente d’acquérir en mode partagé, d’abandon en cas d’interruption et d’échec si le délai d’expiration donné s’écoule. |
| TryRelease(Int32) |
Tente de définir l’état pour refléter une version en mode exclusif. |
| TryReleaseShared(Int32) |
Tente de définir l’état pour refléter une version en mode partagé. |
| UnregisterFromRuntime() |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). (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
| Nom | Description |
|---|---|
| IJavaPeerable.Disposed() |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). (Hérité de Object) |
| IJavaPeerable.DisposeUnlessReferenced() |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). (Hérité de Object) |
| IJavaPeerable.Finalized() |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). (Hérité de Object) |
| IJavaPeerable.JniManagedPeerState |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). (Hérité de Object) |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). (Hérité de Object) |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). (Hérité de Object) |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). (Hérité de Object) |
Méthodes d’extension
| Nom | Description |
|---|---|
| GetJniTypeName(IJavaPeerable) |
Obtient le nom JNI du type de l’instance |
| JavaAs<TResult>(IJavaPeerable) |
Essayez de forcer |
| JavaCast<TResult>(IJavaObject) |
Effectue une conversion de type vérifiée par le runtime Android. |
| JavaCast<TResult>(IJavaObject) |
Fournit une infrastructure permettant d’implémenter des verrous bloquants et des synchronisateurs associés (sémaphores, événements, etc.) qui s’appuient sur des files d’attente de premier entré en premier sorti (FIFO). |
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
Essayez de forcer |