lock::lock

Article
06/07/2013

Construit un objet à partir de lock , qui attendent éventuellement acquérir le verrou pour toujours, pour une quantité d'heure, ou pas du tout.

template<class T> lock(
   T ^ _object
);
template<class T> lock(
   T ^ _object,
   int _timeout
);
template<class T> lock(
   T ^ _object,
   System::TimeSpan _timeout
);
template<class T> lock(
   T ^ _object,
   lock_later
);

Paramètres

_object
Objet à verrouiller.
_timeout
Valeur du délai d'attente en millisecondes ou comme TimeSpan.

Exceptions

Lève ApplicationException si la saisie de verrouillage ne se produit pas avant délai d'attente.

Notes

Les trois premiers formes de la tentative de constructeur d'acquérir un verrou sur _object dans le délai d'attente spécifié (ou Infinite si aucun n'est spécifié).

Le quatrième type de constructeur n'acquiert pas un verrou sur _object.lock_later est membre de lock_when Enum.Utilisez lock::acquire ou lock::try_acquire pour acquérir le verrou dans ce cas.

Le verrou est libéré automatiquement lorsque le destructeur est appelé.

_object ne peut pas être ReaderWriterLock.S'il est, une erreur de compilateur se produira.

Exemple

Cet exemple utilise une seule instance d'une classe entre plusieurs threads.La classe utilise un verrou sur elle-même pour garantir que les accès à ses données internes sont homogènes pour chaque thread.Le thread d'application principal utilise un verrou sur la même instance de la classe pour vérifier périodiquement pour voir si des threads de travail sont toujours présentes, et attend pour quitter jusqu'à ce que tous les threads de travail ont terminé leurs tâches.

// msl_lock_lock.cpp
// compile with: /clr
#include <msclr/lock.h>

using namespace System;
using namespace System::Threading;
using namespace msclr;

ref class CounterClass {
private:
   int Counter;   

public:
   property int ThreadCount;

   // function called by multiple threads, use lock to keep Counter consistent
   // for each thread
   void UseCounter() {
      try {
         lock l(this); // wait infinitely

         Console::WriteLine("In thread {0}, Counter = {1}", Thread::CurrentThread->ManagedThreadId, 
            Counter);

         for (int i = 0; i < 10; i++) {
            Counter++;
            Thread::Sleep(10);
         }
         
         Console::WriteLine("In thread {0}, Counter = {1}", Thread::CurrentThread->ManagedThreadId, 
            Counter);

         Counter = 0;
         // lock is automatically released when it goes out of scope and its destructor is called
      }
      catch (...) {
         Console::WriteLine("Couldn't acquire lock!");
      }

      ThreadCount--;
   }
};

int main() {
   // create a few threads to contend for access to the shared data
   CounterClass^ cc = gcnew CounterClass;
   array<Thread^>^ tarr = gcnew array<Thread^>(5);
   ThreadStart^ startDelegate = gcnew ThreadStart(cc, &CounterClass::UseCounter);
   for (int i = 0; i < tarr->Length; i++) {
      tarr[i] = gcnew Thread(startDelegate);
      cc->ThreadCount++;
      tarr[i]->Start();
   }

   // keep our main thread alive until all worker threads have completed
   lock l(cc, lock_later); // don't lock now, just create the object
   while (true) {
      if (l.try_acquire(50)) { // try to acquire lock, don't throw an exception if can't
         if (0 == cc->ThreadCount) {
            Console::WriteLine("All threads completed.");
            break; // all threads are gone, exit while
         }
         else {
            Console::WriteLine("{0} threads exist, continue waiting...", cc->ThreadCount);
            l.release(); // some threads exist, let them do their work
         }
      }
   }
}