StampedLock 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.
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture.
[Android.Runtime.Register("java/util/concurrent/locks/StampedLock", ApiSince=24, DoNotGenerateAcw=true)]
public class StampedLock : Java.Lang.Object, IDisposable, Java.Interop.IJavaPeerable, Java.IO.ISerializable[<Android.Runtime.Register("java/util/concurrent/locks/StampedLock", ApiSince=24, DoNotGenerateAcw=true)>]
type StampedLock = class
inherit Object
interface ISerializable
interface IJavaObject
interface IDisposable
interface IJavaPeerable- Héritage
- Attributs
- Implémente
Remarques
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. L’état d’un StampedLock se compose d’une version et d’un mode. Les méthodes d’acquisition de verrou retournent un tampon qui représente et contrôle l’accès par rapport à un état de verrouillage ; Les versions « try » de ces méthodes peuvent retourner à la place la valeur spéciale zéro pour représenter l’échec de l’acquisition de l’accès. Les méthodes de mise en production et de conversion de verrou nécessitent des tampons en tant qu’arguments et échouent s’ils ne correspondent pas à l’état du verrou. Les trois modes sont les suivants :
<ul>
<li><b>Écriture.<La méthode #writeLock /b> bloque éventuellement l’attente d’un accès exclusif, retournant un tampon qui peut être utilisé dans la méthode #unlockWrite pour libérer le verrou. Des versions non planifiées et chronométrées sont tryWriteLock également fournies. Lorsque le verrou est conservé en mode écriture, aucun verrou de lecture ne peut être obtenu, et toutes les validations de lecture optimistes échouent.
<li><b>Reading.<La méthode #readLock /b> bloque éventuellement l’attente d’un accès non exclusif, retournant un tampon qui peut être utilisé dans la méthode #unlockRead pour libérer le verrou. Des versions non planifiées et chronométrées sont tryReadLock également fournies.
<li><b>Optimiste Lecture.<La méthode #tryOptimisticRead /b> retourne un tampon non zéro uniquement si le verrou n’est pas conservé en mode écriture. La méthode #validate retourne la valeur true si le verrou n’a pas été acquis en mode écriture depuis l’obtention d’un tampon donné, auquel cas toutes les actions antérieures à la dernière mise en production du verrou d’écriture se produisent avant les actions suivant l’appel à tryOptimisticRead. Ce mode peut être considéré comme une version extrêmement faible d’un verrou en lecture, qui peut être rompu par un enregistreur à tout moment. L’utilisation du mode de lecture optimiste pour les segments de code en lecture seule courte réduit souvent la contention et améliore le débit. Toutefois, son utilisation est intrinsèquement fragile. Les sections de lecture optimistes doivent uniquement lire les champs et les contenir dans des variables locales pour une utilisation ultérieure après validation. Les champs lus en mode lecture optimiste peuvent être incohérents de manière sauvage. L’utilisation s’applique donc uniquement lorsque vous êtes familiarisé avec les représentations de données pour vérifier la cohérence et/ou appeler à plusieurs reprises la méthode validate(). Par exemple, ces étapes sont généralement requises lors de la première lecture d’une référence d’objet ou de tableau, puis l’accès à l’un de ses champs, éléments ou méthodes.
</ul>
Cette classe prend également en charge les méthodes qui fournissent des conversions conditionnellement entre les trois modes. Par exemple, la méthode #tryConvertToWriteLock tente de « mettre à niveau » un mode, renvoyant un tampon d’écriture valide si (1) déjà en mode écriture (2) en mode lecture et qu’il n’y a pas d’autres lecteurs ou (3) en mode lecture optimiste et que le verrou est disponible. Les formes de ces méthodes sont conçues pour aider à réduire certains des ballonnements de code qui se produisent dans les conceptions basées sur les nouvelles tentatives.
StampedLocks est conçu pour être utilisé comme utilitaires internes dans le développement de composants thread-safe. Leur utilisation repose sur la connaissance des propriétés internes des données, des objets et des méthodes qu’ils protègent. Ils ne sont pas réentrants, donc les corps verrouillés ne doivent pas appeler d’autres méthodes inconnues qui peuvent essayer de ré-acquérir des verrous (même si vous pouvez passer un tampon à d’autres méthodes qui peuvent l’utiliser ou la convertir). L’utilisation des modes de verrouillage de lecture s’appuie sur les sections de code associées sans effet secondaire. Les sections de lecture optimiste non valides ne peuvent pas appeler des méthodes qui ne sont pas connues pour tolérer des incohérences potentielles. Les tampons utilisent des représentations finies et ne sont pas sécurisés par chiffrement (c’est-à-dire, un tampon valide peut être deviner). Les valeurs d’horodatage peuvent être recyclées après (pas plus d’un an d’opération continue). Un tampon conservé sans utilisation ni validation pendant plus longtemps que cette période peut échouer à valider correctement. StampedLocks est sérialisable, mais toujours désérialisé dans un état déverrouillé initial, de sorte qu’ils ne sont pas utiles pour le verrouillage à distance.
Comme java.util.concurrent.Semaphore Semaphore, mais contrairement à la plupart Lock des implémentations, StampedLocks n’a aucune notion de propriété. Les verrous acquis dans un thread peuvent être libérés ou convertis dans un autre.
La stratégie de planification de StampedLock ne préfère pas constamment les lecteurs aux rédacteurs ou inversement. Toutes les méthodes « try » sont optimales et ne sont pas nécessairement conformes à une stratégie de planification ou d’équité. Un retour zéro de toute méthode « try » pour l’acquisition ou la conversion de verrous ne contient aucune information sur l’état du verrou ; un appel ultérieur peut réussir.
Étant donné qu’elle prend en charge l’utilisation coordonnée entre plusieurs modes de verrouillage, cette classe n’implémente pas directement les interfaces ou ReadWriteLock les Lock interfaces. Toutefois, un StampedLock peut être consulté #asReadLock(), #asWriteLock()ou #asReadWriteLock() dans les applications nécessitant uniquement l’ensemble de fonctionnalités associé.
<b>Synchronisation de la mémoire.</b> Les méthodes ayant pour effet de verrouiller correctement dans n’importe quel mode ont les mêmes effets de synchronisation de mémoire qu’une <action em>Lock</em>, comme décrit dans le chapitre 17 de <la spécification>/cite> du langage< Java. Les méthodes de déverrouillage en mode écriture ont les mêmes effets de synchronisation de mémoire qu’une <action em>Unlock</em> . Dans les utilisations de lecture optimistes, les actions antérieures à l’action de déverrouillage du mode d’écriture la plus récente sont garanties avant qu’elles ne suivent un tryOptimisticRead que si une validation ultérieure retourne true ; sinon, il n’existe aucune garantie que les lectures entre tryOptimisticRead et validation obtiennent un instantané cohérent.
<b>Exemple d’utilisation.</b> Le code suivant illustre quelques idiomes d’utilisation dans une classe qui conserve des points à deux dimensions simples. L’exemple de code illustre certaines conventions try/catch, même si elles ne sont pas strictement nécessaires ici, car aucune exception ne peut se produire dans leur corps.
{@code
class Point {
private double x, y;
private final StampedLock sl = new StampedLock();
// an exclusively locked method
void move(double deltaX, double deltaY) {
long stamp = sl.writeLock();
try {
x += deltaX;
y += deltaY;
} finally {
sl.unlockWrite(stamp);
}
}
// a read-only method
// upgrade from optimistic read to read lock
double distanceFromOrigin() {
long stamp = sl.tryOptimisticRead();
try {
retryHoldingLock: for (;; stamp = sl.readLock()) {
if (stamp == 0L)
continue retryHoldingLock;
// possibly racy reads
double currentX = x;
double currentY = y;
if (!sl.validate(stamp))
continue retryHoldingLock;
return Math.hypot(currentX, currentY);
}
} finally {
if (StampedLock.isReadLockStamp(stamp))
sl.unlockRead(stamp);
}
}
// upgrade from optimistic read to write lock
void moveIfAtOrigin(double newX, double newY) {
long stamp = sl.tryOptimisticRead();
try {
retryHoldingLock: for (;; stamp = sl.writeLock()) {
if (stamp == 0L)
continue retryHoldingLock;
// possibly racy reads
double currentX = x;
double currentY = y;
if (!sl.validate(stamp))
continue retryHoldingLock;
if (currentX != 0.0 || currentY != 0.0)
break;
stamp = sl.tryConvertToWriteLock(stamp);
if (stamp == 0L)
continue retryHoldingLock;
// exclusive access
x = newX;
y = newY;
return;
}
} finally {
if (StampedLock.isWriteLockStamp(stamp))
sl.unlockWrite(stamp);
}
}
// upgrade read lock to write lock
void moveIfAtOrigin2(double newX, double newY) {
long stamp = sl.readLock();
try {
while (x == 0.0 && y == 0.0) {
long ws = sl.tryConvertToWriteLock(stamp);
if (ws != 0L) {
stamp = ws;
x = newX;
y = newY;
break;
}
else {
sl.unlockRead(stamp);
stamp = sl.writeLock();
}
}
} finally {
sl.unlock(stamp);
}
}
}}
Ajouté dans la version 1.8.
Documentation Java pour java.util.concurrent.locks.StampedLock.
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
| StampedLock() |
Crée un nouveau verrou, initialement dans un état déverrouillé. |
| StampedLock(IntPtr, JniHandleOwnership) |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. |
Propriétés
| Class |
Retourne la classe runtime de ce |
| Handle |
Handle de l’instance Android sous-jacente. (Hérité de Object) |
| IsReadLocked |
Retourne |
| IsWriteLocked |
Retourne |
| JniIdentityHashCode |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. (Hérité de Object) |
| JniPeerMembers |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. |
| PeerReference |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. (Hérité de Object) |
| ReadLockCount |
Interroge le nombre de verrous de lecture conservés pour ce verrou. |
| ThresholdClass |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. |
| ThresholdType |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. |
Méthodes
| AsReadLock() |
Retourne une vue simple |
| AsReadWriteLock() |
Retourne une |
| AsWriteLock() |
Retourne une vue simple |
| Clone() |
Crée et retourne une copie de cet objet. (Hérité de Object) |
| Dispose() |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. (Hérité de Object) |
| Dispose(Boolean) |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. (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) |
| IsLockStamp(Int64) |
Indique si un tampon représente la conservation d’un verrou. |
| IsOptimisticReadStamp(Int64) |
Indique si un tampon représente une lecture optimiste réussie. |
| IsReadLockStamp(Int64) |
Indique si un tampon représente la conservation d’un verrou non exclusif. |
| IsWriteLockStamp(Int64) |
Indique si un tampon représente la conservation exclusive d’un verrou. |
| 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) |
| ReadLock() |
Non exclusivement acquiert le verrou, bloquant si nécessaire jusqu’à ce que disponible. |
| ReadLockInterruptibly() |
Acquiert non exclusivement le verrou, bloquant si nécessaire jusqu’à ce que disponible ou le thread actuel soit interrompu. |
| SetHandle(IntPtr, JniHandleOwnership) |
Définit la propriété Handle. (Hérité de Object) |
| ToArray<T>() |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. (Hérité de Object) |
| ToString() |
Retourne une représentation de chaîne de l'objet. (Hérité de Object) |
| TryConvertToOptimisticRead(Int64) |
Si l’état du verrou correspond à l’empreinte donnée, de façon atomique, si l’empreinte représente la conservation d’un verrou, la libère et retourne un tampon d’observation. |
| TryConvertToReadLock(Int64) |
Si l’état de verrouillage correspond à l’empreinte donnée, effectue atomiquement l’une des actions suivantes. |
| TryConvertToWriteLock(Int64) |
Si l’état de verrouillage correspond à l’empreinte donnée, effectue atomiquement l’une des actions suivantes. |
| TryOptimisticRead() |
Retourne un tampon qui peut être validé ultérieurement, ou zéro s’il est verrouillé exclusivement. |
| TryReadLock() |
Acquiert non exclusivement le verrou s’il est immédiatement disponible. |
| TryReadLock(Int64, TimeUnit) |
Acquiert non exclusivement le verrou s’il est disponible dans le temps donné et que le thread actuel n’a pas été interrompu. |
| TryUnlockRead() |
Libère une conservation du verrou de lecture s’il est conservé, sans nécessiter de valeur d’horodatage. |
| TryUnlockWrite() |
Libère le verrou d’écriture s’il est conservé, sans nécessiter de valeur d’empreinte. |
| TryWriteLock() |
Acquiert exclusivement le verrou s’il est immédiatement disponible. |
| TryWriteLock(Int64, TimeUnit) |
Acquiert exclusivement le verrou s’il est disponible dans le temps donné et que le thread actuel n’a pas été interrompu. |
| Unlock(Int64) |
Si l’état du verrou correspond au tampon donné, libère le mode correspondant du verrou. |
| UnlockRead(Int64) |
Si l’état du verrou correspond au tampon donné, libère le verrou non exclusif. |
| UnlockWrite(Int64) |
Si l’état du verrou correspond au tampon donné, libère le verrou exclusif. |
| UnregisterFromRuntime() |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. (Hérité de Object) |
| Validate(Int64) |
Retourne true si le verrou n’a pas été acquis exclusivement depuis l’émission du tampon donné. |
| 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) |
| WriteLock() |
Acquiert exclusivement le verrou, bloquant si nécessaire jusqu’à ce que disponible. |
| WriteLockInterruptibly() |
Acquiert exclusivement le verrou, bloquant si nécessaire jusqu’à ce que disponible ou le thread actuel soit interrompu. |
Implémentations d’interfaces explicites
| IJavaPeerable.Disposed() |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. (Hérité de Object) |
| IJavaPeerable.DisposeUnlessReferenced() |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. (Hérité de Object) |
| IJavaPeerable.Finalized() |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. (Hérité de Object) |
| IJavaPeerable.JniManagedPeerState |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. (Hérité de Object) |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. (Hérité de Object) |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. (Hérité de Object) |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. (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) |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. |
| GetJniTypeName(IJavaPeerable) |
Verrou basé sur des fonctionnalités avec trois modes de contrôle de l’accès en lecture/écriture. |