exPRession represents the object you wish to track, usually an object reference. Generally, if you want to protect an instance of a class, you can use this; if you want to protect a static variable (such as a mutually exclusive code segment inside a static method), generally use the class name. The statement_block is the code of the mutually exclusive section. This code can only be executed by one thread at a time.
The following is a typical example of using the lock keyword. I will explain the usage and purpose of the lock keyword in the comments:
//lock.cs
using System;
using System. Threading;
internal class Account
{
int balance;
Random r = new Random();
internal Account(int initial)
{
balance = initial;
}
internal int Withdraw(int amount)
{
if (balance < 0 )
{
//If balance is less than 0, throw an exception
throw new Exception("Negative Balance");
}
//The following code ensures that before the current thread completes modifying the value of balance
//No other thread will execute this code to modify balance Value
//Therefore, the value of balance cannot be less than 0
lock (this)
{
Console .WriteLine("Current Thread:"+Thread.CurrentThread.Name);
//If there is no protection of the lock keyword, it may be after executing the if conditional judgment
//Another thread executed balance=balance-amount and modified the value of balance
//This modification is invisible to this thread, so it may cause the if The condition is no longer true
//However, this thread continues to execute balance=balance-amount, so the balance may be less than 0
if (balance >= balance = balance - amount; return amount;
return 0; // transaction rejected {
for (int i = 0; i < 100; i++)
Withdraw(r.Next(-50, 100));
}
}
internal class Test
{
static internal Thread[] threads = new Thread[10];
public static void Main()
{
Account acc = new Account (0);
for (int i = 0; i < 10; i++)
{
Thread t = new Thread(new ThreadStart(acc.DoTransactions));
threads[i] = t; int i = 0; i < 10; i++)
threads[i].Name=i.ToString();
threads[i].Start();
Console.ReadLine(); When threads share an object, problems similar to common code will also occur. For this kind of problem, the lock keyword should not be used. A class Monitor in System.Threading needs to be used here. We can call it monitor. Monitor Provides a solution for threads to share resources.
The Monitor class can lock an object, and a thread can only operate on the object if it obtains the lock. The object lock mechanism ensures that only one thread can access this object at a time in situations that may cause chaos. Monitor must be associated with a specific object, but because it is a static class, it cannot be used to define objects, and all its methods are static and cannot be referenced using objects. The following code illustrates the situation of using Monitor to lock an object:
...
Queue oQueue=new Queue();
...
Monitor.Enter(oQueue );
......//Now the oQueue object can only be manipulated by the current thread
Monitor.Exit(oQueue);//Release the lock
As shown above, when a thread calls the Monitor.Enter() method to lock an object, the object is owned by it. If other threads want to access this object, they can only wait for it to use the Monitor.Exit() method to release the lock. . In order to ensure that the thread will eventually release the lock, you can write the Monitor.Exit() method in the finally code block in the try-catch-finally structure. For any object locked by the Monitor, some information related to it is stored in the memory. One is the reference of the thread currently holding the lock, and the other is a preparation queue, which stores the objects that are ready to acquire the lock. The third thread is a waiting queue, which holds a reference to the queue that is currently waiting for the object's state to change. When the thread that owns the object lock is ready to release the lock, it uses the Monitor.Pulse() method to notify the first thread in the waiting queue, so the thread is transferred to the preparation queue. When the object lock is released, in the preparation queue The thread can immediately acquire the object lock.
The following is an example showing how to use the lock keyword and Monitor class to achieve thread synchronization and communication. It is also a typical producer and consumer problem. In this routine, the producer thread and the consumer thread alternate. The producer writes a number, and the consumer immediately reads and displays it. I will introduce the essence of the program in the comments. The system namespace used is as follows:
using System;
using System.Threading
The above is the content of the preliminary exploration of C#’s multi-threading mechanism (4). For more related content, please pay attention to the PHP Chinese website (www. php.cn)!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
