C# Version HisotryC# Language FeaturesInstalling Visual StudioC# Basic Project StructureHello Wolrd, first C# program
Variables in C# Explicitly typed variables in C#Implicitly typed variables in C#Constants in C#Data types in C#Integral data types in C#Floating-point data types in C#Comparison between Float, Double and DecimalChar data type in C#String data type in C#Boolean data type in C#DateTime data type in C#Enumeration data type in C#Array data type in C#Object data type in C#Dynamic data type in C#Anonymous data type in C#Nullable data type in C#Type casting in C#Type safety in C#Literals in C#Operators in C#Ternary Operator in C#Null coalescing Operator in C#Tilde(~) Operator in C#Keywords in C#Namespace in C#Nullable Types in C#Nullable Helper Class in C#Characteristics of Nullable typesC# Difference between "int" and "int?"
Block statement in C#Empty statement in C#Jump statements in C#Break statement in C#Continue statement in C#Difference between continue and breakGoto statement in C#Return statement in C#Throw statement in C#Yield keyword in C#Checked statement in C#Unchecked statement in C#Lock statement in C#Using statement in C#Enum/Enumeration in C#If-Else statement in C#Switch statement in C#What is a loop in C#?For loop in C#While loop in C#Do while loop in C#Foreach loop in C#Nested loop in C#Infinite loop in C#
C# Method or FunctionC# Method Parameters and ArgumentsC# Method OverloadingC# Return StatementsC# Static vs. Instance MethodsC# Method ModifiersC# Method Signatures and Naming ConventionsC# Function Documentation and CommentsC# Value Type ParametersC# Ref Type ParametersDifference between Value and Ref TypeC# Out ParametersDifference between Ref and out parametersC# Optional parametersAre Nullable types reference types in C#"
Exception Handling in C#Types of exception in C#Try catch finally in C#finally block in C#try block without catch blockMultiple catch blocks in exceptionCatch multiple exceptions in C#Base class of exception in C#finally block execution in C#finally block execution in case of errorFinally and return statementWays to use try-catch-finallyException throw from finally block"throw" and "throw ex" in C#Differene between finalize() and finallyInner exception in C#Error types in C#Catch multi exception by single catch blockUser defined/custom excetion in C#Compile and run time exception in C#Difference between "error" and "exception"System and application exception in C#Exception handling abuse in c#?
C# String BasicsC# String ManipulationC# String FormattingC# String Comparison and SearchingC# StringBuilder ClassC# Regular ExpressionsC# Unicode and EncodingC# String Parsing and ConversionDifference between "string" and "String"C# String Escape SequenceC# Mutable and Immutable ConceptProve that string is immutableString value stored in memoryDifference between string and stringbuilderOverride the tostring() method
Enum/enumeration in C#Can you inherit enum in C#?Convert enum to stringConvert enum to list in C#Cast int value to enum in C#Get int value from enum in C#Convert string to enum in C#Usage of enum in switch case statementLoop through all enum valuesUse tilde(~) with Enum
Main() method basics in C#More than one "Main()" method in C#Static Main() method in C#Overload Main() method in C#Override Main() method in C#Access modifiers of Main() method in C#Non-static method in C#Main() method arguments and return typeasync Main() method in C#Class without Main() method in C#Main() method rules in C#
Recursion in C#Base condition in recursion in C#Recursive Algorithms in C#Tree traversal using recursion in C#Stack overflow error in recursionBack tracking using recursionIndirect recursion in C#Recursive data structures in C#Tail Recursion in C#Recursive problem solvingRecursion vs Iteration
C# File and File InfoC# StreamReader and StreamWriterC# FileStream and BinaryReader/BinaryWriterC# Directory and DirectoryInfo ClassesC# File PathsC# File and Directory OperationsC# File Exceptions and Error HandlingC# File Serialization and DeserializationC# File System Watcher
What is array?Single dimension arrayMulti dimension arrayJagged arrayParam arrayArray with multi data typesDifferent data types from object arrayArray with non-default valuesArray methods and propertiesArray manipulation techniquesArray sorting algorithmsArray Searching algorithms(linear, binary search)Array finding maximum and minimumArray of Reference Types
C# GenericsC# Generic Constraints
C# ArrayListC# Array vs ArrayListC# ListC# SortedListC# DictionaryC# HashtableC# Dictionary vs HashtableC# HashSetC# Hashtable vs HashSetC# StackC# Queue
C# IEnumerableC# IEnumeratorC# ICollectionC# IListC# IDictionaryC# IDisposableC# IComparableC# IEquatableC# ICloneableC# IQueryableC# INotifyPropertyChangedC# INotifyCollectionChangedC# IFormattableC# IAsyncResultC# IComparerC# IEqualityComparerC# IHttpHandlerC# IHttpModule
C# DelegatesC# Single-Cast DelegateC# Multi-Cast DelegateC# Generic DelegatesC# Func DelegateC# Action DelegateC# Predicate DelegateC# Anonymous MethodsC# EventsDifference Between Event & DelegateDifference Between Interface & DelegateC# Covariance and Contravariance
Previous
Next

C# - lock statement

In C#, the lock statement is used to ensure that a block of code is executed by only one thread at a time. It helps prevent multiple threads from accessing shared resources simultaneously, which can lead to data corruption or unexpected behavior in a multithreaded application.

The general syntax of the lock statement is as follows: 


lock (lockObject)
{
    // Code block that needs to be executed in a mutually exclusive manner
}

Here's a simple example that illustrates how to use the lock statement in C#:


using System;
using System.Threading;

class Program
{
    static readonly object lockObject = new object();
    static int sharedVariable = 0;

    static void Main()
    {
        // Create two threads that will increment the shared variable
        Thread thread1 = new Thread(IncrementSharedVariable);
        Thread thread2 = new Thread(IncrementSharedVariable);

        // Start both threads
        thread1.Start();
        thread2.Start();

        // Wait for both threads to finish
        thread1.Join();
        thread2.Join();

        // Display the final value of the shared variable
        Console.WriteLine("Shared Variable: " + sharedVariable);
    }

    static void IncrementSharedVariable()
    {
        for (int i = 0; i < 100000; i++)
        {
            // Use the lock statement to ensure only one thread can access this block at a time
            lock (lockObject)
            {
                sharedVariable++;
            }
        }
    }
}

In this example:

  1. We define a lockObject as a synchronization object to ensure exclusive access to the critical section of code.
  2. We have a sharedVariable that will be incremented by two threads.
  3. We create two threads (thread1 and thread2) that both execute the IncrementSharedVariable method.
  4. Inside the IncrementSharedVariable method, we use the lock statement with lockObject to protect the sharedVariable from concurrent access. This means that only one thread can enter the critical section at a time.
  5. Each thread increments the sharedVariable 100,000 times within the critical section.
  6. After both threads have finished their work, we display the final value of the sharedVariable. Since the lock statement ensures exclusive access, the final value should be 200,000 (100,000 increments from each thread).

Possible Output:


Shared Variable: 200000

This demonstrates how the lock statement helps prevent data corruption when multiple threads access shared resources concurrently.

Using the Lock Statement in C# - Office Printer Example

Let's explore a real-time example of using the lock statement in C# to manage access to a shared printer in an office.


using System;
using System.Threading;

class OfficePrinter
{
    static readonly object printerLock = new object(); // Our lock, like the printer access control

    static void Main()
    {
        // Simulate multiple employees (threads) sending print jobs
        Thread employee1 = new Thread(SendPrintJob);
        Thread employee2 = new Thread(SendPrintJob);

        employee1.Start("Employee 1: Report");
        employee2.Start("Employee 2: Presentation");
    }

    static void SendPrintJob(object document)
    {
        string job = (string)document;

        lock (printerLock) // Similar to locking access to the printer
        {
            Console.WriteLine(job + " is being printed...");

            // Simulate printing process
            Thread.Sleep(2000);

            Console.WriteLine(job + " has been printed.");
        }
    }
}

In this example:

  1. We have a printerLock, which is like the lock on the printer access control. It ensures that only one employee (thread) can send a print job to the printer at a time.
  2. We simulate two employees (employee1 and employee2) sending print jobs concurrently by starting two threads.
  3. Inside the SendPrintJob method, when an employee wants to send a print job (enters the lock block), they "lock" access to the printer (acquire the lock) to prevent other employees from sending print jobs simultaneously.
  4. While an employee's print job is being processed (inside the lock block), other employees have to wait for their turn to use the printer.
  5. After the first print job is completed (the lock is released), the next employee can send their print job, and the process repeats.

Expected Output:


Employee 1: Report is being printed...
Employee 2: Presentation is being printed...
Employee 1: Report has been printed.
Employee 2: Presentation has been printed.

This example demonstrates how the lock statement in C# ensures that only one thread can access a critical section of code (in this case, sending a print job to the printer) at a time, preventing conflicts and ensuring orderly access to shared resources.

Points to Remember:
  1. Thread Synchronization: The lock statement is used for thread synchronization, protecting critical sections of code from being accessed by multiple threads simultaneously.
  2. Object-Based Locking: It requires an object (often called a "lock object" or "monitor") to serve as the synchronization lock, ensuring exclusive access to the locked code block.
  3. Prevents Race Conditions: It helps prevent race conditions where multiple threads attempt to access and modify shared resources concurrently, which can lead to data corruption or unpredictable behavior.
  4. Scope of Lock: Keep the locked code block as small as possible to minimize contention and improve performance, enclosing only the code that truly needs protection.
  5. Exception Handling: Always use the try...finally construct with the lock statement to ensure the lock is released, even in case of exceptions within the locked code block.
  6. Deadlocks: Be cautious about potential deadlocks, which can occur when multiple threads are waiting for each other to release locks. Proper design and usage of locks can help avoid deadlocks.
  7. Lock Object Consistency: Use the same lock object consistently by all threads that need to access the shared resource to ensure proper synchronization.
  8. Avoid Overuse: While locks are essential for managing shared resources, excessive use can lead to performance issues, so use them judiciously.
  9. Monitor.Exit: The lock statement is a syntactic sugar for Monitor.Enter and Monitor.Exit calls. You can manually release a lock using Monitor.Exit(lockObject) if needed.
  10. Nested Locks: Be cautious when using nested locks, as locking on the same object within a locked block can lead to deadlocks. Consider alternatives like separate lock objects.
  11. Lock-Free Algorithms: In some cases, lock-free data structures or algorithms may be more efficient and eliminate the need for locks while ensuring thread safety.
  12. Performance Considerations: Locking can introduce contention and affect performance. Profiling and optimizing your code are important to avoid bottlenecks when using locks.
  13. Thread Safety: The lock statement is a fundamental way to achieve thread safety in multithreaded applications, but it's crucial to design your application with thread safety in mind from the beginning.
  14. Alternative Synchronization: Depending on your specific use case, other synchronization primitives like Mutex, Semaphore, and ReaderWriterLock might be more suitable than lock.
  15. Testing and Debugging: Thoroughly test and debug your multithreaded code to identify and resolve synchronization issues early in the development process.
Previous
Next