lock — Instrukcja (odwołanie w C#)
lock Słowa kluczowego oznacza blok instrukcji jako sekcji krytycznej uzyskiwania blokady wzajemnego wykluczenia dla danego obiektu, wykonywania instrukcji, a następnie zwolnienie blokady.Poniższy przykład zawiera lock instrukcji.
class Account
{
decimal balance;
private Object thisLock = new Object();
public void Withdraw(decimal amount)
{
lock (thisLock)
{
if (amount > balance)
{
throw new Exception("Insufficient funds");
}
balance -= amount;
}
}
}
Aby uzyskać więcej informacji, zobacz Synchronizacja wątku (C# i Visual Basic).
Uwagi
lock Słowa kluczowego gwarantuje, że jeden wątek nie wejść do sekcji krytycznej kodu, podczas gdy inny wątek jest w sekcji krytycznej.Jeśli inny wątek usiłuje wprowadzić kod zablokowane, będzie czekać, blokowania, dopóki obiekt nie zostanie zwolniona.
Sekcja Wątkowość (C# i Visual Basic) omówiono wątków.
lock Wywołania słowa kluczowego Enter na początku bloku i Exit na końcu bloku.A ThreadInterruptedException jest generowany, gdy Interrupt przerywa wątek oczekuje na wprowadź lock instrukcji.
Ogólnie należy unikać blokowania na public typu lub wystąpień poza kontrolą Twój kod.Konstrukcje wspólnej lock (this), lock (typeof (MyType)), i lock ("myLock") naruszają Niniejsze wytyczne:
lock (this)jest to problem, jeśli wystąpienie dostępne publicznie.
lock (typeof (MyType))jest to problem, jeśli MyType są publicznie dostępne.
lock("myLock")jest to problem, ponieważ inny kod procesu przy użyciu samego ciągu będzie udostępniać blokadę.
Najlepszym rozwiązaniem jest zdefiniowanie private obiekt, aby zablokować, lub private static zmienną obiektu, aby chronić dane wspólne dla wszystkich wystąpień.
Nie można użyć czekają na słowa kluczowego w treści lock instrukcji.
Przykład
Poniżej przedstawiono przykładowe proste użycie wątków bez blokowania w C#.
//using System.Threading;
class ThreadTest
{
public void RunMe()
{
Console.WriteLine("RunMe called");
}
static void Main()
{
ThreadTest b = new ThreadTest();
Thread t = new Thread(b.RunMe);
t.Start();
}
}
// Output: RunMe called
W poniższym przykładzie użyto wątków i lock.Tak długo, jak lock deklaracji, instrukcji bloku jest sekcji krytycznej i balance nigdy nie staną się liczbę ujemną.
// using System.Threading;
class Account
{
private Object thisLock = new Object();
int balance;
Random r = new Random();
public Account(int initial)
{
balance = initial;
}
int Withdraw(int amount)
{
// This condition never is true unless the lock statement
// is commented out.
if (balance < 0)
{
throw new Exception("Negative Balance");
}
// Comment out the next line to see the effect of leaving out
// the lock keyword.
lock (thisLock)
{
if (balance >= amount)
{
Console.WriteLine("Balance before Withdrawal : " + balance);
Console.WriteLine("Amount to Withdraw : -" + amount);
balance = balance - amount;
Console.WriteLine("Balance after Withdrawal : " + balance);
return amount;
}
else
{
return 0; // transaction rejected
}
}
}
public void DoTransactions()
{
for (int i = 0; i < 100; i++)
{
Withdraw(r.Next(1, 100));
}
}
}
class Test
{
static void Main()
{
Thread[] threads = new Thread[10];
Account acc = new Account(1000);
for (int i = 0; i < 10; i++)
{
Thread t = new Thread(new ThreadStart(acc.DoTransactions));
threads[i] = t;
}
for (int i = 0; i < 10; i++)
{
threads[i].Start();
}
}
}
Specyfikacja języka C#
Aby uzyskać więcej informacji, zobacz Specyfikacja języka C#. Specyfikacja języka jest ostatecznym źródłem informacji o składni i użyciu języka C#.
Zobacz też
Informacje
Słowa kluczowe instrukcji (odwołanie w C#)
Synchronizacja wątku (C# i Visual Basic)
Koncepcje
Przewodnik programowania w języku C#