Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Diese Klasse automatisiert die Sperre zum Synchronisieren des Zugriffs auf ein Objekt aus mehreren Threads. Beim Bau erhält sie die Sperre und wenn sie zerstört wird, wird die Sperre freigegeben.
Syntax
ref class lock;
Hinweise
lock ist nur für CLR-Objekte verfügbar und kann nur im CLR-Code verwendet werden.
Intern verwendet Monitor die Sperrklasse zum Synchronisieren des Zugriffs. Weitere Informationen finden Sie im referenzierten Artikel.
Member
Öffentliche Konstruktoren
| Name | Beschreibung |
|---|---|
| lock::lock | Erstellt ein lock Objekt, das optional darauf wartet, die Sperre für immer abzurufen, für einen bestimmten Zeitraum oder gar nicht. |
| lock::~lock | Destruktiert ein lock Objekt. |
Öffentliche Methoden
| Name | Beschreibung |
|---|---|
| lock::acquire | Erwirbt eine Sperre für ein Objekt, optional darauf, die Sperre für immer abzurufen, für einen bestimmten Zeitraum oder gar nicht. |
| lock::is_locked | Gibt an, ob eine Sperre gehalten wird. |
| lock::release | Gibt eine Sperre frei. |
| lock::try_acquire | Erwirbt eine Sperre für ein Objekt, wartet auf eine bestimmte Zeitspanne und gibt einen bool Wert zurück, um den Kauferfolg zu melden, anstatt eine Ausnahme auszulösen. |
Öffentliche Operatoren
| Name | Beschreibung |
|---|---|
| lock::operator bool | Operator für die Verwendung lock in einem bedingten Ausdruck. |
| lock::operator== | Gleichheitsoperator. |
| lock::operator!= | Ungleichheitsoperator. |
Anforderungen
Headerdatei<msclr\lock.h>
Namespace msclr
lock::lock
Erstellt ein lock Objekt, das optional darauf wartet, die Sperre für immer abzurufen, für einen bestimmten Zeitraum oder gar nicht.
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
_Objekt
Das zu sperrende Objekt.
_Zeitüberschreitung
Timeoutwert in Millisekunden oder als .TimeSpan
Ausnahmen
Löst aus ApplicationException , wenn der Sperrerwerb nicht vor dem Timeout erfolgt.
Hinweise
Die ersten drei Formen des Konstruktors versuchen, eine Sperre _object innerhalb des angegebenen Timeoutzeitraums zu erhalten (oder Infinite wenn keine angegeben ist).
Die vierte Form des Konstruktors erhält keine Sperre _object. lock_later ist Mitglied der lock_when Enumeration. Verwenden Sie "lock::acquire " oder "lock::try_acquire ", um die Sperre in diesem Fall zu erwerben.
Die Sperre wird automatisch freigegeben, wenn der Destruktor aufgerufen wird.
_object kann nicht sein ReaderWriterLock. Wenn dies der Grund ist, führt ein Compilerfehler zu einem Fehler.
Beispiel
In diesem Beispiel wird eine einzelne Instanz einer Klasse über mehrere Threads hinweg verwendet. Die Klasse verwendet eine Sperre für sich selbst, um sicherzustellen, dass der Zugriff auf die internen Daten für jeden Thread konsistent ist. Der Hauptanwendungsthread verwendet eine Sperre für dieselbe Instanz der Klasse, um regelmäßig zu überprüfen, ob noch Arbeitsthreads vorhanden sind. Die Hauptanwendung wartet dann, bis alle Arbeitsthreads ihre Aufgaben abgeschlossen haben.
// 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
}
}
}
}
In thread 3, Counter = 0
In thread 3, Counter = 10
In thread 5, Counter = 0
In thread 5, Counter = 10
In thread 7, Counter = 0
In thread 7, Counter = 10
In thread 4, Counter = 0
In thread 4, Counter = 10
In thread 6, Counter = 0
In thread 6, Counter = 10
All threads completed.
lock::~lock
Destruktiert ein lock Objekt.
~lock();
Hinweise
Der Destruktor ruft lock::release auf.
Beispiel
In diesem Beispiel wird eine einzelne Instanz einer Klasse über mehrere Threads hinweg verwendet. Die Klasse verwendet eine Sperre für sich selbst, um sicherzustellen, dass der Zugriff auf die internen Daten für jeden Thread konsistent ist. Der Hauptanwendungsthread verwendet eine Sperre für dieselbe Instanz der Klasse, um regelmäßig zu überprüfen, ob noch Arbeitsthreads vorhanden sind. Die Hauptanwendung wartet dann, bis alle Arbeitsthreads ihre Aufgaben abgeschlossen haben.
// msl_lock_dtor.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
}
}
}
}
In thread 3, Counter = 0
In thread 3, Counter = 10
In thread 5, Counter = 0
In thread 5, Counter = 10
In thread 7, Counter = 0
In thread 7, Counter = 10
In thread 4, Counter = 0
In thread 4, Counter = 10
In thread 6, Counter = 0
In thread 6, Counter = 10
All threads completed.
lock::acquire
Erwirbt eine Sperre für ein Objekt, optional darauf, die Sperre für immer abzurufen, für einen bestimmten Zeitraum oder gar nicht.
void acquire();
void acquire(
int _timeout
);
void acquire(
System::TimeSpan _timeout
);
Parameter
_Zeitüberschreitung
Timeoutwert in Millisekunden oder als .TimeSpan
Ausnahmen
Löst aus ApplicationException , wenn der Sperrerwerb nicht vor dem Timeout erfolgt.
Hinweise
Wenn kein Timeoutwert angegeben wird, ist Infinitedas Standardtimeout .
Wenn bereits eine Sperre abgerufen wurde, führt diese Funktion nichts aus.
Beispiel
In diesem Beispiel wird eine einzelne Instanz einer Klasse über mehrere Threads hinweg verwendet. Die Klasse verwendet eine Sperre für sich selbst, um sicherzustellen, dass der Zugriff auf die internen Daten für jeden Thread konsistent ist. Der Hauptanwendungsthread verwendet eine Sperre für dieselbe Instanz der Klasse, um regelmäßig zu überprüfen, ob noch Arbeitsthreads vorhanden sind. Die Hauptanwendung wartet dann, bis alle Arbeitsthreads ihre Aufgaben abgeschlossen haben.
// msl_lock_acquire.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
}
}
}
}
In thread 3, Counter = 0
In thread 3, Counter = 10
In thread 5, Counter = 0
In thread 5, Counter = 10
In thread 7, Counter = 0
In thread 7, Counter = 10
In thread 4, Counter = 0
In thread 4, Counter = 10
In thread 6, Counter = 0
In thread 6, Counter = 10
All threads completed.
lock::is_locked
Gibt an, ob eine Sperre gehalten wird.
bool is_locked();
Rückgabewert
true wenn eine Sperre gehalten wird, false andernfalls.
Beispiel
In diesem Beispiel wird eine einzelne Instanz einer Klasse über mehrere Threads hinweg verwendet. Die Klasse verwendet eine Sperre für sich selbst, um sicherzustellen, dass der Zugriff auf die internen Daten für jeden Thread konsistent ist. Der Hauptanwendungsthread verwendet eine Sperre für dieselbe Instanz der Klasse, um regelmäßig zu überprüfen, ob noch Arbeitsthreads vorhanden sind, und wartet, bis alle Arbeitsthreads ihre Aufgaben abgeschlossen haben.
// msl_lock_is_locked.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) {
l.try_acquire(50); // try to acquire lock, don't throw an exception if can't
if (l.is_locked()) { // check if we got the lock
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
}
}
}
}
In thread 3, Counter = 0
In thread 3, Counter = 10
In thread 5, Counter = 0
In thread 5, Counter = 10
In thread 4, Counter = 0
In thread 4, Counter = 10
In thread 7, Counter = 0
In thread 7, Counter = 10
In thread 6, Counter = 0
In thread 6, Counter = 10
All threads completed.
lock::operator bool
Operator für die Verwendung lock in einem bedingten Ausdruck.
operator bool();
Rückgabewert
true wenn eine Sperre gehalten wird, false andernfalls.
Hinweise
Dieser Operator konvertiert tatsächlich, was _detail_class::_safe_bool sicherer ist, als bool weil er nicht in einen integralen Typ konvertiert werden kann.
Beispiel
In diesem Beispiel wird eine einzelne Instanz einer Klasse über mehrere Threads hinweg verwendet. Die Klasse verwendet eine Sperre für sich selbst, um sicherzustellen, dass der Zugriff auf die internen Daten für jeden Thread konsistent ist. Der Hauptanwendungsthread verwendet eine Sperre für dieselbe Instanz der Klasse, um regelmäßig zu überprüfen, ob noch Arbeitsthreads vorhanden sind. Die Hauptanwendung wartet auf das Beenden, bis alle Arbeitsthreads ihre Aufgaben abgeschlossen haben.
// msl_lock_op_bool.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) {
l.try_acquire(50); // try to acquire lock, don't throw an exception if can't
if (l) { // use bool operator to check for lock
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
}
}
}
}
In thread 3, Counter = 0
In thread 3, Counter = 10
In thread 5, Counter = 0
In thread 5, Counter = 10
In thread 7, Counter = 0
In thread 7, Counter = 10
In thread 4, Counter = 0
In thread 4, Counter = 10
In thread 6, Counter = 0
In thread 6, Counter = 10
All threads completed.
lock::release
Gibt eine Sperre frei.
void release();
Hinweise
Wenn keine Sperre gehalten wird, release geschieht nichts.
Sie müssen diese Funktion nicht explizit aufrufen. Wenn ein lock Objekt außerhalb des Gültigkeitsbereichs ist, ruft dessen Destruktor auf release.
Beispiel
In diesem Beispiel wird eine einzelne Instanz einer Klasse über mehrere Threads hinweg verwendet. Die Klasse verwendet eine Sperre für sich selbst, um sicherzustellen, dass der Zugriff auf die internen Daten für jeden Thread konsistent ist. Der Hauptanwendungsthread verwendet eine Sperre für dieselbe Instanz der Klasse, um regelmäßig zu überprüfen, ob noch Arbeitsthreads vorhanden sind. Die Hauptanwendung wartet dann, bis alle Arbeitsthreads ihre Aufgaben abgeschlossen haben.
// msl_lock_release.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
}
}
}
}
In thread 3, Counter = 0
In thread 3, Counter = 10
In thread 5, Counter = 0
In thread 5, Counter = 10
In thread 7, Counter = 0
In thread 7, Counter = 10
In thread 4, Counter = 0
In thread 4, Counter = 10
In thread 6, Counter = 0
In thread 6, Counter = 10
All threads completed.
lock::try_acquire
Erwirbt eine Sperre für ein Objekt, wartet auf eine bestimmte Zeitspanne und gibt einen bool Wert zurück, um den Kauferfolg zu melden, anstatt eine Ausnahme auszulösen.
bool try_acquire(
int _timeout_ms
);
bool try_acquire(
System::TimeSpan _timeout
);
Parameter
_Zeitüberschreitung
Timeoutwert in Millisekunden oder als .TimeSpan
Rückgabewert
true wenn die Sperre erworben wurde, false andernfalls.
Hinweise
Wenn bereits eine Sperre abgerufen wurde, führt diese Funktion nichts aus.
Beispiel
In diesem Beispiel wird eine einzelne Instanz einer Klasse über mehrere Threads hinweg verwendet. Die Klasse verwendet eine Sperre für sich selbst, um sicherzustellen, dass der Zugriff auf die internen Daten für jeden Thread konsistent ist. Der Hauptanwendungsthread verwendet eine Sperre für dieselbe Instanz der Klasse, um regelmäßig zu überprüfen, ob noch Arbeitsthreads vorhanden sind. Die Hauptanwendung wartet dann, bis alle Arbeitsthreads ihre Aufgaben abgeschlossen haben.
// msl_lock_try_acquire.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
}
}
}
}
In thread 3, Counter = 0
In thread 3, Counter = 10
In thread 5, Counter = 0
In thread 5, Counter = 10
In thread 7, Counter = 0
In thread 7, Counter = 10
In thread 4, Counter = 0
In thread 4, Counter = 10
In thread 6, Counter = 0
In thread 6, Counter = 10
All threads completed.
lock::operator==
Gleichheitsoperator.
template<class T> bool operator==(
T t
);
Parameter
t
Das Objekt, das für Gleichheit verglichen werden soll.
Rückgabewert
Gibt zurück true , wenn t das Objekt der Sperre identisch ist, false andernfalls.
Beispiel
// msl_lock_op_eq.cpp
// compile with: /clr
#include <msclr/lock.h>
using namespace System;
using namespace System::Threading;
using namespace msclr;
int main () {
Object^ o1 = gcnew Object;
lock l1(o1);
if (l1 == o1) {
Console::WriteLine("Equal!");
}
}
Equal!
lock::operator!=
Ungleichheitsoperator.
template<class T> bool operator!=(
T t
);
Parameter
t
Das Objekt, das für Ungleichheiten verglichen werden soll.
Rückgabewert
Gibt zurück true , wenn t sich das Objekt der Sperre unterscheidet, false andernfalls.
Beispiel
// msl_lock_op_ineq.cpp
// compile with: /clr
#include <msclr/lock.h>
using namespace System;
using namespace System::Threading;
using namespace msclr;
int main () {
Object^ o1 = gcnew Object;
Object^ o2 = gcnew Object;
lock l1(o1);
if (l1 != o2) {
Console::WriteLine("Inequal!");
}
}
Inequal!