lock::lock

Erstellt ein lock-Objekt und optional für die Sperre wartet, dass immer für die angegebene Zeitdauer oder überhaupt nicht abgerufen werden.

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
);

Parameter

_object
Das zu sperrende Objekt.
_timeout
Timeoutwert in Millisekunden) oder als TimeSpan.

Ausnahmen

Löst ApplicationException aus, wenn das Sperren von nicht vor dem Timeout eintritt.

Hinweise

Die ersten drei Formen des Konstruktors Versuch, eine Sperre auf _object innerhalb des angegebenen Timeouts (oder Infinite abzurufen, wenn kein Wert angegeben wurde).

Das vierte Form des Konstruktors ruft keine Sperre für _object ab.lock_later ist ein Member lock_when Enumeration.Verwenden Sie lock::acquire oder lock::try_acquire, um die Sperre in diesem Fall abzurufen.

Die Sperre wird automatisch freigegeben, wenn der Destruktor aufgerufen wird.

_object darf nicht ReaderWriterLock sein.Wenn dies der Fall ist, ergibt sich ein Kompilierungsfehler auf.

Beispiel

In diesem Beispiel wird eine einzelne Instanz einer Klasse über mehrere Threads.Die Klasse wird eine Sperre auf, um sicherzustellen, dass Zugriffe auf die internen Daten für jeden Thread konsistent sind.Der Hauptanwendungsthread verwendet eine Sperre auf der gleichen Instanz der Klasse, um in regelmäßigen Abständen zu überprüfen, um festzustellen, falls vorhanden, Arbeitsthreads immer noch vorhanden sind und wartet, um zu beenden, nachdem alle Arbeitsthreads ihre Aufgaben ausgeführt wurden.

// 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
         }
      }
   }
}