C # Lock and monitor introduction (multi-thread Concurrency Control)

Here we will introduce the C # Lock keyword. It can define a piece of code as a critical section. A mutex can only be executed by one thread at a time, while other threads must wait.

 

C # language is worth learning a lot. Here we mainly introduce the C # Lock keyword, including the locking of an object in the monitor class.

C # provides a lock keyword, which defines a piece of code as a critical section. A mutex section allows only one thread to enter the execution at a time point, other threads must wait. In C #, the C # Lock keyword is defined as follows:

Lock (expression) statement_block

Expression indicates the object you want to trace. It is usually an object reference.
◆ If you want to protect an instance of a class, you can generally use this;
◆ If you want to protect a static variable (for example, the mutex code segment is inside a static method), you can use a class name.

The statement_block is the code of the mutex, which can be executed by only one thread at a time.

The following is a typical example of using the C # Lock keyword. The usage and usage of the C # Lock keyword are described in the annotations.

Example:

 
 

  
  
Using system;
  
  
Using system. Threading;
  
  
 
  
  
Namespace threadsimple
  
  
{
  
  
Internal class account
  
  
{
  
  
Int balance;
  
  
Random r = new random ();
  
  
 
  
  
Internal account (INT initial)
  
  
{
  
  
Balance = initial;
  
  
}
  
  
Internal int withdraw (INT amount)
  
  
{
  
  
If (balance< 0)
  
  
{
  
  
// If the balance is smaller than 0, an exception is thrown.
  
  
Throw new exception ("negative balance ");
  
  
}
  
  
// The following Code ensures that the balance value is modified by the current thread.
  
  
// No other threads will execute this code to modify the balance value.
  
  
// Therefore, the balance value cannot be smaller than 0.
  
  
Lock (this)
  
  
{
  
  
Console. writeline ("current thread:" + thread. currentthread. Name );
  
  
// If the lock keyword is not protected, it may be after the if condition is determined.
  
  
// Another thread executes balancebalance = balance-amount and modifies the balance value.
  
  
// This modification is invisible to this thread, so it may cause the if condition to be invalid.
  
  
// However, this thread continues to execute balancebalance = balance-amount, so the balance may be less than 0
  
  
If (balance>= Amount)
  
  
{
  
  
Thread. Sleep (5 );
  
  
Balancebalance = balance-amount;
  
  
Return amount;
  
  
}
  
  
Else
  
  
{
  
  
Return 0; // Transaction rejected
  
  
}
  
  
}
  
  
}
  
  
Internal void dotransactions ()
  
  
{
  
  
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;
  
  
}
  
  
For (INT I = 0; I< 10; I ++)
  
  
Threads [I]. Name = I. tostring ();
  
  
For (INT I = 0; I< 10; I ++)
  
  
Threads [I]. Start ();
  
  
Console. Readline ();
  
  
}
  
  
}
  
  
}
 
 

The monitor class locks an object.

When multiple threads share an object, a problem similar to that of public code may also occur. In this case, the C # Lock keyword should not be used. System is used here. A kind of Monitor In threading is called a monitor, which provides a solution to share resources with threads.

The monitor class can lock an object. A thread can operate on this object only when this lock is obtained. The object lock mechanism ensures that only one thread can access this object at a time point that may cause confusion. Monitor must be associated with a specific object, but because it is a static class, it cannot be used to define the object, and all its methods are static, objects cannot be referenced. The following code uses 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 monitor. when the enter () method locks an object, this object will be owned by it. Other threads want to access this object, only waiting for it to use monitor. the exit () method releases the lock. To ensure that the thread can release the lock in the end, you can write the monitor. Exit () method into the finally code block in the try-catch-Finally structure.