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

Rohan Wiese

2y692C#

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

4 Replies

Know the answer? Post it — somebody with the same question will find it here.

Mithilesh Tata2y ago
Accepted 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:
1. 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.
2. 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.
3. 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.
+4
Tuhin Paul2y ago
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.
0

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 < threads.Length; i++)
        {
            threads[i] = new Thread(() =>
            {
                // Simulate deposit and withdrawal operations
                Random random = new Random();
                for (int j = 0; j < 3; j++)
                {
                    decimal depositAmount = random.Next(100, 500);
                    decimal withdrawalAmount = random.Next(100, 500);
                    
                    account.Deposit(depositAmount);
                    account.Withdraw(withdrawalAmount);
                }
            });
            threads[i].Start();
        }

        // Wait for all threads to complete
        foreach (Thread thread in threads)
        {
            thread.Join();
        }

        // Display final balance
        Console.WriteLine($"Final balance: {account.GetBalance()}");
    }
}

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 Hawaldar2y ago
https://www.c-sharpcorner.com/UploadFile/de41d6/monitor-and-lock-in-C-Sharp/
+1