Die Sperrsyntax lautet:
private object o = new object();//创建一个对象
public void Work()
{
lock(o)//锁住这个对象
{
//做一些必须按照顺序做的事情
}
}Der Zweck besteht darin, dass beim Multithreading nach Verwendung der Sperre der Codeblock in der angegebenen Reihenfolge ausgeführt werden kann und einer der Threads auf den gesperrten Code zugegriffen hat, sodass der andere Thread nur warten kann.
Wenn Sie die Theorie nicht verstehen, sehen Sie sich die nachstehende Aufschlüsselung an.
1. Wenn Sie sich diesen Code ansehen, beginnt er mit der Ausführung von oben, führt zuerst A und dann B aus. Dies ist ein Single-Thread-Programm, das der Reihe nach ausgeführt wird und dessen Ergebnis zu diesem Zeitpunkt steuerbar ist.
2. Wir haben Multithreading hinzugefügt, das die gleichzeitige Ausführung der Methoden A und B ermöglicht. Zu diesem Zeitpunkt ist das Ergebnis unkontrollierbar. Manchmal wird Methode B zuerst ausgeführt, manchmal wird Methode A zuerst ausgeführt.
Führen Sie zuerst Methode B aus.
Führen Sie zuerst Methode A aus.
Warum A zuerst ausgeführt wird, dann B ausgeführt wird oder B zuerst ausgeführt wird und dann A ausgeführt wird, wird vom Betriebssystem basierend auf der CPU automatisch berechnet. Man sieht, dass unser Problem kommt. Kann es so gemacht werden, dass es in mehreren Threads ausgeführt werden kann und die Reihenfolge von A und B kontrolliert werden kann? Dadurch wird die Sperre verwendet.
3. Der gewünschte Effekt besteht daher darin, dass im Fall von Multithreading entweder zuerst A oder zuerst B ausgeführt wird. A und B können nicht verschachtelt ausgeführt werden, sie müssen nacheinander ausgeführt werden. Sobald das Programm die Sperre betritt, wird es gesperrt. Auf den gesperrten Code kann zu diesem Zeitpunkt nur ein Thread zugreifen. Erst nachdem der Zugriff dieses Threads beendet ist, können andere Threads darauf zugreifen.
Um den Kontrast zu erhöhen, fügen wir eine weitere C-Methode hinzu
Wirkung
der Code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace ConsoleApp2
{
class Program
{
static int a = 0;
static int b = 0;
private static object o = new object();
static void Main(string[] args)
{
//A();
//B();
Thread t1 = new Thread(A);
Thread t2 = new Thread(B);
t1.Start();
t2.Start();
Thread t3 = new Thread(C);
t3.Start();
Console.ReadLine();
}
private static void A()
{
lock (o)
{
a = a + 2;
Console.WriteLine("我是A方法，a=" + a);
Thread.Sleep(5000);//暂停5秒
b = b + 2;
Console.WriteLine("我是A方法，b=" + b);
}
}
private static void B()
{
lock (o)
{
b++;
Console.WriteLine("我是B方法，b=" + b);
Thread.Sleep(1000); //暂停1秒
a++;
Console.WriteLine("我是B方法，a=" + a);
}
}
private static void C()
{
Console.WriteLine("我是C方法，随机出现");
}
}
}
expandieren
Tatsächlich entspricht die Sperre dem Monitor.
lock(o);
{
do
}Gleichwertig
Monitor.Enter(o);
{
do
}
Monitor.Exit(o);Enter entspricht der Eingabe dieses Codeblocks und Exit dem Verlassen dieses Codeblocks. Wenn dieser Codeblock erneut ausgeführt wird, können andere Threads nicht darauf zugreifen. Das {} in Monitor kann entfernt werden, ohne dass es davon betroffen ist.
der Code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace ConsoleApp2
{
class Program
{
static int a = 0;
static int b = 0;
private static object o = new object();
static void Main(string[] args)
{
//A();
//B();
Thread t1 = new Thread(A);
Thread t2 = new Thread(B);
t1.Start();
t2.Start();
Thread t3 = new Thread(C);
t3.Start();
Console.ReadLine();
}
private static void A()
{
//lock (o)
Monitor.Enter(o);
a = a + 2;
Console.WriteLine("我是A方法，a=" + a);
Thread.Sleep(5000);//暂停5秒
b = b + 2;
Console.WriteLine("我是A方法，b=" + b);
Monitor.Exit(o);
}
private static void B()
{
//lock (o)
Monitor.Enter(o);
b++;
Console.WriteLine("我是B方法，b=" + b);
Thread.Sleep(1000); //暂停1秒
a++;
Console.WriteLine("我是B方法，a=" + a);
Monitor.Exit(o);
}
private static void C()
{
Console.WriteLine("我是C方法，随机出现");
}
}
}