Multi Threading Best Dot Net Training

  • Multi-Threading Best Dot Net Training
  • Thread: The path of execution of instructions within a process is called a thread. A program with multiple simultaneous paths of execution is said to be a multi-threaded application.

  • A running instance of an application is a process. Every process has its own memory address space and it is in that all the data and the instructions of that process reside.

     

Types of Scheduling:

Preemptive: OS can un-schedule a thread even if it is not completed its task.

NonPreemptive: OS cannot unschedule the thread when it is not completed. A Thread should either unschedule itself of should complete its task.

  • Scheduling is done based on the priority of the thread. A thread with highest priority is executed in the processor. If multiple threads with exist same priority then a time slice is assigned to each thread.

  • In MS-Windows execution of the thread is based on: Preemptive Scheduling Priority Time slice

  • Also, in all versions of MS Windows, to avoid starvation low priority threads are also executed in the processor but the number of times they execute is very less.

  1. Running: A thread is said to be in running state when it is in a processor executing one of its instruction.

  2. Ready: Thread is waiting for the processor to be allocated to it. This is the only entry point to running state. When the tread is unscheduled it returns from running to ready state.

  3. Dead: After the execution of all the instructions in the thread it goes to the dead state. Dead threads cannot be revived.

  4. Sleeping: While sleeping the thread doesn’t perform any task. A thread goes to sleeping state by itself and for a predefined time. A sleeping thread when interrupted throws “ThreadInterruptedException”. All the resources/locks that the thread is holding are blocked when a thread is in sleeping state.

  5. Suspended: A thread can suspend itself or by another thread. The suspended thread cannot resume by itself. A thread can go to suspended state for an indefinite time.

  6. Blocked: A thread is said to be in the blocked state when the resources are not available to it and it is waiting for them. The thread automatically resumes once the resource is made available.

  7. Waiting: The thread before it goes to waiting for state releases its resources/locks it has blocked. A waiting thread has to be pulled by another thread only then it can resume and goes to the ready state.

    In.Net every thread has two objects associated with it.

  1. An Object of type System.Threading.Threads and it is responsible for managing the lifetime and the states of the thread.

  2. A custom object, it is responsible for providing the instructions and data which the thread has to manage during its lifetime.

Example 1:

using System;

using System. Threading;

class Demo

{

       public string Message;

      public int Interval = 1000;

      public void Run()

     {

        for (int i = 0; i < 5; i++) //while(true)

      {

Console.WriteLine(Thread.CurrentThread.Name

+ ” : ” + Message);

      Thread.Sleep(Interval);

      }

   }

}

  • Demo class encapsulates the instructions of thread in Run method and also encapsulates data in Message and Interval data members.

  • The process terminates when the main thread terminates.

  • A thread terminates only when the other non-background threads which it has created terminates.

  • The creator doesn’t wait for the background thread if it has to terminate.

class Program

{

static void Main(string[] args)

{

Console.WriteLine(“Main method begins”);

     Demo d = new Demo();

    Thread t = new Thread(new        ThreadStart(d.Run));

   t.Name = “T”;

  d.Message = “Hi”;

  d.Interval = 1000;

 t.Start();

 Demo d1 = new Demo();

  Thread t1 = new Thread(new   ThreadStart(d1.Run));

  t1.Name = “T1”;

  d1.Message = “Hello”;

  d1.Interval = 2000;

  t1.Start();

  t.Join(2000);

  if (t.IsAlive)

  Console.WriteLine(“t is alive”);

  t1.Join();

  //t1.IsBackground =   t.IsBackground = true;

Console.WriteLine(“Main method ends”);

  }

}

t.Join():If a thread executes t.Join() the current thread state is changed to waiting and it remains in that state until the thread referred by “t” is terminated.

Join(3000) – The current threads waits for a max of 3000 milliseconds and then would resume automatically.

t.IsAlive() to check if the thread is dead or alive..

Thread.CurrentThread: To Get the reference of the current thread.

t.ThreadPriority = ThreadPriority.Highest.

t.Abort(): To stop the thread. When the Abort() method is called on a thread it throws ThreadAbortException irrespective of its state. If this exception is unhandled the thread terminates, and if it is handled and if Thread.ResetAbort() is executed the thread is not aborted and would continue normal execution.

t.IsBackground: When a thread is created as a background thread, the creator thread does not wait for the background thread to terminate or join the creator thread. The background thread is automatically aborted when the creator thread aborts.

Example 2: Program to Print “Data” at a regular input and also facility to change that data by reading its value from the keyboard.

class PrintThread

{

   public string Data;

   public void Run()

  {

   while (true)

  {

  Console.WriteLine(Data);

  Thread.Sleep(1000);

}

}

}

class PrintProgram

{

    public static void Main()

   {

      PrintThread p = new PrintThread();

   Thread t = new Thread(new ThreadStart(p.Run));

    t.Start();

   while (true)

   {

      Console.WriteLine(“Please enter the data: “);

       p.Data = Console.ReadLine();

   }

   }

}

Example 3: To Demonstrate the Priority of Thread

In windows OS for every cycle of high priority thread scheduled in the processor, the priority of low priority thread is boosted by one unit. This is done so that even those threads whose priority is low are given a chance to execute in the processor to avoid starvation.

Priority Demo

class Hello

{

    public long Counter;

    public void Run()

    {

       while(true)

        Counter++;

    }

}

Note: On Dual Core processor machine, this program should be executed with three threads because the processor would execute two threads at the same time irrespective of their priority.

class PriorityProgram

{

static void Main(string[] args)

{

Hello h1 = new Hello();

Thread t1 = new Thread(new ThreadStart(h1.Run));

Hello h2 = new Hello();

Thread t2 = new Thread(new ThreadStart(h2.Run));

t1.Priority = ThreadPriority.AboveNormal;

t2.Priority = ThreadPriority.BelowNormal;

Thread.CurrentThread.Priority = ThreadPriority.Highest;

t1.Start(); t2.Start();

Thread.Sleep(2000);

t1.Abort(); t2.Abort();

double perT1 = 100.0 * h1.Counter / (h1.Counter + h2.Counter);

double perT2 = 100.0 * h2.Counter / (h1.Counter + h2.Counter);

Console.WriteLine(“T1 ” + perT1);

Console.WriteLine(“T2 ” + perT2);

}

}

Suspend-Resume / Sleep – Interrupt / Abort Demo

Add to the project a new Windows Form: (DemoForm)

private void Run()

{

    int n = 0;

   while (true)

   {

     try

   {

            n++;

      lblCounter.Text = n.ToString();

     Thread.Sleep(1000);

}

catch (ThreadAbortException e)

{

      DialogResult dlgResult;

dlgResult = MessageBox.Show(“Are you sure?”,

“Abort”, MessageBoxButtons.YesNo);

if (dlgResult == DialogResult.No)

Thread.ResetAbort();

}

catch (ThreadInterruptedException e)

{

                n = 0;

}

}

}

Thread t;

private void btnStart_Click(. . .)

{

    t = new Thread(new ThreadStart(Run));

    t.IsBackground = true;

    t.Start();

}

private void btnAbort_Click(. . .)

{

          t.Abort();

}

private void btnSuspend_Click(. . .)

{

           t.Suspend();

}

private void btnResume_Click(. . .)

{

               t.Resume();

}

private void btnInterrupt_Click(. . .)

{

                 t.Interrupt();

}

private void btnThreadState_Click(. . .)

{ MessageBox.Show(t.ThreadState.ToString());

}

//To make form as the startup object.

public static void Main()

{

Application.Run(new DemoForm());

}

In Project Properties: Change Output Type to Windows Application and Startup Object to DemoForm

Thread Synchronization

Requirement: In situation where one object is shared by more than one thread, if the thread has to modify the state of the object it should ensured that only one thread does so at a given instance of time.

Critical Section is a block of code which can be executed by only one thread at any given instance of time.

If there are two threads executing on a same shared object then both the threads can execute some method on the object at the same point of time and if they then change the state of the object, it may result in the ambiguity of data causing Threads De-Synchronization. To avoid this we use lock block.

In C#

lock(ob)

{

}

In VB

SyncLock (ob)

End SyncLock

Every object in .NET has a special type of resource called as Monitor. A thread trying to enter the lock block would have to acquire the monitor of the specified object and only if it can do so it would be executing the locked block other wise it will have to wait for the monitor.

Example

class Shared

{

              int n;

             public int Incr()

             {

               lock (this)

              {

                  n++;

                 int k = 0;

for (long i = 0; i < 100000000; i++)

          k++;

          return n;

     }

    }

}

class Demo

{

          Shared s;

           public Demo(Shared s)

          {

             this.s = s;

            }

public void Run()

{

//lock (s) //To be used if the Demo.Incr is not coded

//{ for Thread Safety (not having lock block)

Console.WriteLine(s.Incr());

//}

}

}

class SyncDemo

{

public static void Main()

{

           Shared s = new Shared();

           Demo d1 = new Demo(s);

           Demo d2 = new Demo(s);

          Thread t1 = new Thread(new             ThreadStart(d1.Run));

        Thread t2 = new Thread(new           ThreadStart(d2.Run));

         t1.Start();t2.Start();

    }

}

  1. Thread safe class: A class whose objects state is not desynchronized when it is being used by more than one thread at the same time.

  2. Even if the class is not threaded safe (methods changing the state of the object do not have code inside lock block) we can still make use its functionality in the multithreaded environment by calling all its method within a lock block on the same object.

  3. If a thread has acquired a monitor of an object, it can enter any number of lock blocks in different methods of the same object.

  4. Locking degrades throughput i.e. the rate at which the output is generated.

  5. Shared / Static members of a class can synchronize the code in them by acquiring the lock on Type instance of that class.

Mutex

It is a synchronization resource managed by the OS. Thus it can be used for synchronizing threads running in different processes.

Note: Monitor is an a.Net specific object and is local to a given process and thus it cannot be used for synchronizing threads running in different processes.

If two or more threads have to be synchronized using Mutex, then either they should all refer to the same Mutex object or if the objects are different then all the Mutex objects must have the same name so that all the mutex objects refer to the same mutex resource in the OS.

WaitOne(): Check for the availability of mutex. If available acquires it and would continue execution other the current thread state is changed to waiting for the mutex.

ReleseMutex() – Releases the mutex

Mutex m = new Mutex(false, “test”);

If the first parameter is true, the first thread creating the mutex object will be the owner of the mutex. False will prevent the thread object to acquire the mutex till WaitOne() method is executed.

“test” is the name of the mutex as identified in OS.

Example 1

FileStream fs;

StreamWriter sw;

Mutex m = new Mutex(false, “M1”);

private void btnOpenFile_Click(object sender, EventArgs e)

{

bool flag = m.WaitOne(0,false);

if (!flag)

{

MessageBox.Show(“File is already being used by another app”);

   return;

}

fs = new FileStream(“c:\\mutexdemo.txt”, FileMode.Create);

sw = new StreamWriter(fs);

btnOpenFile.Enabled = false;

btnCloseFile.Enabled = true;

btnWriteToFile.Enabled = true;

}

private void btnCloseFile_Click(object sender, EventArgs e)

{

sw.Close();

fs.Close();

btnOpenFile.Enabled = true;

btnCloseFile.Enabled = false;

btnWriteToFile.Enabled = false;

m.ReleaseMutex();

}

private void btnWriteToFile_Click(object sender, EventArgs e)

{

sw.Write(txtText.Text);

txtText.Text = “”;

}

public static void Main()

{

Application.Run(new MutexDemoForm());

}

Example 2:

To allow only once instance of the application to run at a time.

public static void Main()

{

Mutex m = new Mutex(false, “M1”);

bool firstInstance = m.WaitOne(0,true);

if (firstInstance)

{

Application.Run(new MainForm());

m.ReleaseMutex();

}

else

MessageBox.Show(“Instance already running”);

}

Note:

Use Ctrl + F5 for executing the Program Two times

Semaphore

Semaphore is used for synchronizing threads (within and in different process) and it works exactly like Mutex but has a facility to allow more than one thread (but a pre defined count) to execute a given block at the same time.

A mutex can be treated as a special case of semaphore where count = 1.

class Demo1

{

//static Semaphore s = new Semaphore(3,3);

Semaphore s = new Semaphore(3,3, “Test”);

public void Run()

{

Console.WriteLine(Thread.CurrentThread.Name

+ ” Started”);

        s.WaitOne();

        Thread.Sleep(1000);

        s.Release();

Console.WriteLine(Thread.CurrentThread.Name

+ ” Ended”);

}

}

class SemaphoreDemo

{

public static void Main()

{

for (int i = 0; i < 15; i++)

{

        Demo1 d = new Demo1();

           Thread t = new Thread(

         new ThreadStart(d.Run));

          t.Name = “T” + i;

           t.Start();

}

Console.WriteLine(“Main method ends”);

}

}

              Mr Sandeep Soni, CEO & Founder of Deccansoft Software Services. He has over 21years of External 100000+ students Deccansoft has trained, he has personally trained over 60,000+ students and we are proud of him because almost every student he had trained is very happy with the quality and many are well placed in various I.T Firms. This will reflect in testimonials on our website.perience in Teaching and Development using Microsoft Technologies. Since 1997, of the to


 

Please follow and like us:
0

Leave a Reply

Your email address will not be published. Required fields are marked *