Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

ReaderWriterLock.UpgradeToWriterLock méthode (Int32)

 

Date de publication : novembre 2016

Met à niveau un verrou de lecteur vers le verrou de writer en utilisant une valeur Int32 pour définir le délai d'attente.

Espace de noms:   System.Threading
Assembly:  mscorlib (dans mscorlib.dll)

public LockCookie UpgradeToWriterLock(
	int millisecondsTimeout
)

Paramètres

millisecondsTimeout
Type: System.Int32

Délai en millisecondes.

Valeur de retour

Type: System.Threading.LockCookie

Valeur LockCookie.

Exception Condition
ApplicationException

millisecondsTimeout expire avant que la demande de verrou est accordée.

Lorsqu’un thread appelle UpgradeToWriterLock le verrou de lecteur est libéré, quel que soit le nombre de verrous, et le thread se place à la fin de la file d’attente pour le verrou de writer. Par conséquent, les autres threads peuvent écrire dans la ressource avant que le thread qui a demandé que la mise à niveau est accordé le verrou de writer.

System_CAPS_importantImportant

L’exception de délai d’attente n’est pas levée tant que le thread qui a appelé la UpgradeToWriterLock méthode peut acquérir le verrou de lecteur. S’il n’existe aucun autre thread n’attend le verrou de writer, cela se produit immédiatement. Toutefois, si un autre thread est en attente pour le verrou de writer, le thread qui a appelé la UpgradeToWriterLock méthode ne peut pas réacquérir le verrou de lecteur tant que tous les lecteurs actuels ont libéré leurs verrous, et un thread a acquis et libéré le verrou de writer. Cela est vrai même si l’autre thread qui a demandé le verrou de writer a demandé après que le thread actuel a appelé la UpgradeToWriterLock méthode.

Pour restaurer l’état du verrou, appelez DowngradeFromWriterLock à l’aide de la LockCookie retourné par UpgradeToWriterLock. N’utilisez pas cette LockCookie avec RestoreLock.

Lorsqu’un thread ne possède aucun verrou de lecteur, n’utilisez pas UpgradeToWriterLock. Utilisez plutôt AcquireWriterLock.

Pour les valeurs de délai d’attente valides, consultez la page ReaderWriterLock.

L’exemple de code suivant montre comment demander un verrou de lecteur, mettre à niveau le verrou de lecteur vers un verrou de writer et rétrograder à nouveau vers un verrou de lecteur.

Ce code fait partie d’un exemple plus complet fourni pour la ReaderWriterLock classe.

// The complete code is located in the ReaderWriterLock class topic.
using System;
using System.Threading;

public class Example
{
   static ReaderWriterLock rwl = new ReaderWriterLock();
   // Define the shared resource protected by the ReaderWriterLock.
   static int resource = 0;
// Requests a reader lock, upgrades the reader lock to the writer
// lock, and downgrades it to a reader lock again.
static void UpgradeDowngrade(int timeOut)
{
   try {
      rwl.AcquireReaderLock(timeOut);
      try {
         // It's safe for this thread to read from the shared resource.
         Display("reads resource value " + resource);
         Interlocked.Increment(ref reads);

         // To write to the resource, either release the reader lock and
         // request the writer lock, or upgrade the reader lock. Upgrading
         // the reader lock puts the thread in the write queue, behind any
         // other threads that might be waiting for the writer lock.
         try {
            LockCookie lc = rwl.UpgradeToWriterLock(timeOut);
            try {
               // It's safe for this thread to read or write from the shared resource.
               resource = rnd.Next(500);
               Display("writes resource value " + resource);
               Interlocked.Increment(ref writes);
            }
            finally {
               // Ensure that the lock is released.
               rwl.DowngradeFromWriterLock(ref lc);
            }
         }
         catch (ApplicationException) {
            // The upgrade request timed out.
            Interlocked.Increment(ref writerTimeouts);
         }

         // If the lock was downgraded, it's still safe to read from the resource.
         Display("reads resource value " + resource);
         Interlocked.Increment(ref reads);
      }
      finally {
         // Ensure that the lock is released.
         rwl.ReleaseReaderLock();
      }
   }
   catch (ApplicationException) {
      // The reader lock request timed out.
      Interlocked.Increment(ref readerTimeouts);
   }
}

.NET Framework
Disponible depuis 1.1
Retour au début
Afficher: