What is the purpose of the 'lock' keyword in C#? How does it work?

Question

I have basic knowledge of C#. Please explain the purpose of the 'lock' keyword in C# and its uses.

Mithilesh Tata · Answer

The purpose of the 'lock' keyword in C# is to provide a simple and effective way to synchronize access to shared resources in a multi-threaded environment. It helps prevent race conditions where multiple threads may attempt to access or modify the same resource concurrently, leading to unpredictable behavior or data corruption. Here's how the 'lock' keyword works: Acquiring a Lock : When a thread encounters a 'lock' statement, it attempts to acquire a lock on the specified object or resource. This lock prevents other threads from entering the critical section of code protected by the 'lock' statement. Execution of Critical Section : Once a thread successfully acquires the lock, it can proceed to execute the critical section of code enclosed within the 'lock' statement. This critical section typically involves accessing or modifying shared resources that need to be synchronized. Releasing the Lock : After the thread completes the execution of the critical section, it releases the lock by exiting the 'lock' statement. This allows other threads waiting to acquire the lock to proceed with their execution. Here's a basic example demonstrating the usage of the 'lock' keyword: class SharedResource { private int counter = 0; private object lockObject = new object(); public void IncrementCounter() { lock (lockObject) // Acquire a lock on the lockObject { counter++; // Critical section - accessing shared resource } // Release the lock } } In this example, multiple threads may call the 'IncrementCounter' method concurrently. However, only one thread at a time can execute the critical section of code within the 'lock' statement, ensuring that the 'counter' variable is incremented safely without risk of data corruption due to concurrent access. It's important to note that the object specified in the 'lock' statement serves as the synchronization object, and it's crucial to choose a suitable object to lock on to prevent deadlocks or contention issues. Additionally, the 'lock' statement automatically releases the lock even if an exception occurs within the critical section, ensuring proper synchronization.

Tuhin Paul · Answer

In this example: We have a BankAccount class representing a bank account with methods to deposit and withdraw funds, as well as a method to retrieve the balance. We use the lock keyword to synchronize access to the balance field within the deposit and withdrawal methods to ensure thread safety. We create multiple threads to simulate concurrent access to the bank account. Each thread performs a series of random deposit and withdrawal operations. Finally, we display the final balance of the bank account after all threads have completed their operations.

Tuhin Paul · Answer

using System; using System.Threading; class BankAccount { private decimal balance; private object balanceLock = new object(); // Object used for synchronization public BankAccount(decimal initialBalance) { balance = initialBalance; } public decimal GetBalance() { lock (balanceLock) { return balance; } } public void Deposit(decimal amount) { lock (balanceLock) { balance += amount; Console.WriteLine($"Deposited {amount}. New balance: {balance}"); } } public void Withdraw(decimal amount) { lock (balanceLock) { if (balance >= amount) { balance -= amount; Console.WriteLine($"Withdrawn {amount}. New balance: {balance}"); } else { Console.WriteLine("Insufficient funds for withdrawal."); } } } } class Program { static void Main(string[] args) { BankAccount account = new BankAccount(1000); // Create multiple threads to simulate concurrent access Thread[] threads = new Thread[5]; for (int i = 0; i { // Simulate deposit and withdrawal operations Random random = new Random(); for (int j = 0; j let's consider a scenario where multiple threads are accessing and modifying a shared resource, such as a bank account balance. Without proper synchronization, concurrent access to the balance could lead to incorrect results due to race conditions. We'll use the lock keyword to ensure that only one thread can access the balance at a time, preventing data corruption.

Rajanikant Hawaldar · Answer

https://www.c-sharpcorner.com/UploadFile/de41d6/monitor-and-lock-in-C-Sharp/