Scribd Logo
Upload

Welcome to Scribd!

  • 10 views

    C Lock

    Uploaded by

    Nenad Femic
    This document discusses using locks in C# for thread synchronization. It provides an example of printing numbers from 1 to 10 using two threads, with the PrintTable method locked using the lock keyword. This ensures synchronous execution with the second thread starting only after the first thread completes. Without the lock, the threads would interleave asynchronously. The document also provides another example of synchronizing access to an Account balance field across threads using locking.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd

    C Lock

    Uploaded by

    Nenad Femic
    10 views4 pages
    This document discusses using locks in C# for thread synchronization. It provides an example of printing numbers from 1 to 10 using two threads, with the PrintTable method locked using the lock keyword. This ensures synchronous execution with the second thread starting only after the first thread completes. Without the lock, the threads would interleave asynchronously. The document also provides another example of synchronizing access to an Account balance field across threads using locking.

    Original Description:

    c lock

    Original Title

    c lock

    Copyright

    © © All Rights Reserved

    Available Formats

    DOCX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    This document discusses using locks in C# for thread synchronization. It provides an example of printing numbers from 1 to 10 using two threads, with the PrintTable method locked using the lock keyword. This ensures synchronous execution with the second thread starting only after the first thread completes. Without the lock, the threads would interleave asynchronously. The document also provides another example of synchronizing access to an Account balance field across threads using locking.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    10 views4 pages

    C Lock

    Uploaded by

    Nenad Femic
    This document discusses using locks in C# for thread synchronization. It provides an example of printing numbers from 1 to 10 using two threads, with the PrintTable method locked using the lock keyword. This ensures synchronous execution with the second thread starting only after the first thread completes. Without the lock, the threads would interleave asynchronously. The document also provides another example of synchronizing access to an Account balance field across threads using locking.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    You are on page 1of 4

    C# Thread Synchronization Example

    In this example, we are using lock. This example executes synchronously. In other words, there is no context-
    switching between the threads. In the output section, we can see that second thread starts working after first
    threads finishes its tasks.

    1. using System;  
    2. using System.Threading;  
    3. class Printer  
    4. {  
    5.     public void PrintTable()  
    6.     {  
    7.         lock (this)  
    8.         {  
    9.             for (int i = 1; i <= 10; i++)  
    10.             {  
    11.                 Thread.Sleep(100);  
    12.                 Console.WriteLine(i);  
    13.             }  
    14.         }  
    15.     }  
    16. }  
    17. class Program  
    18. {  
    19.     public static void Main(string[] args)  
    20.     {  
    21.         Printer p = new Printer();  
    22.         Thread t1 = new Thread(new ThreadStart(p.PrintTable));  
    23.         Thread t2 = new Thread(new ThreadStart(p.PrintTable));  
    24.         t1.Start();  
    25.         t2.Start();  
    26.     }  
    27. }  

    Output:

    1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10
    C# Lock
    We can use C# lock keyword to execute program synchronously. It is used to get lock for the current
    thread, execute the task and then release the lock. It ensures that other thread does not interrupt the
    execution until the execution finish.

    Here, we are creating two examples that executes asynchronously and synchronously.

    C# Example: Without Synchronization


    In this example, we are not using lock. This example executes asynchronously. In other words, there is
    context-switching between the threads.

    1. using System;  
    2. using System.Threading;  
    3. class Printer  
    4. {  
    5.     public void PrintTable()  
    6.     {  
    7.         for (int i = 1; i <= 10; i++)  
    8.         {  
    9.             Thread.Sleep(100);  
    10.             Console.WriteLine(i);  
    11.         }  
    12.     }  
    13. }  
    14. class Program  
    15. {  
    16.     public static void Main(string[] args)  
    17.     {  
    18.         Printer p = new Printer();  
    19.         Thread t1 = new Thread(new ThreadStart(p.PrintTable));  
    20.         Thread t2 = new Thread(new ThreadStart(p.PrintTable));  
    21.         t1.Start();  
    22.         t2.Start();  
    23.     }  
    24. }  

    Output:

    1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10
    Example

    The following example defines an Account class that synchronizes access to its private balance field by locking on
    a dedicated balanceLock instance. Using the same instance for locking ensures that the balance field cannot be
    updated simultaneously by two threads attempting to call the Debit or Credit methods simultaneously.

    C#
    using System;
    using System.Threading.Tasks;

    public class Account


    {
    private readonly object balanceLock = new object();
    private decimal balance;

    public Account(decimal initialBalance)


    {
    balance = initialBalance;
    }

    public decimal Debit(decimal amount)


    {
    lock (balanceLock)
    {
    if (balance >= amount)
    {
    Console.WriteLine($"Balance before debit :{balance, 5}");
    Console.WriteLine($"Amount to remove :{amount, 5}");
    balance = balance - amount;
    Console.WriteLine($"Balance after debit :{balance, 5}");
    return amount;
    }
    else
    {
    return 0;
    }
    }
    }

    public void Credit(decimal amount)


    {
    lock (balanceLock)
    {
    Console.WriteLine($"Balance before credit:{balance, 5}");
    Console.WriteLine($"Amount to add :{amount, 5}");
    balance = balance + amount;
    Console.WriteLine($"Balance after credit :{balance, 5}");
    }
    }
    }
    class AccountTest
    {
    static void Main()
    {
    var account = new Account(1000);
    var tasks = new Task[100];
    for (int i = 0; i < tasks.Length; i++)
    {
    tasks[i] = Task.Run(() => RandomlyUpdate(account));
    }
    Task.WaitAll(tasks);
    }

    static void RandomlyUpdate(Account account)


    {
    var rnd = new Random();
    for (int i = 0; i < 10; i++)
    {
    var amount = rnd.Next(1, 100);
    bool doCredit = rnd.NextDouble() < 0.5;
    if (doCredit)
    {
    account.Credit(amount);
    }
    else
    {
    account.Debit(amount);
    }
    }
    }
    }

    You might also like