Working with Threads in C#
(Part 1)
Chapter 3
Outline
◼ Introduction
◼ What is a Thread?
◼ Threads vs Processes
❑ Process Model
❑ Thread Model
◼ Why do we need threads?
◼ Multithreading
◼ Advantages of Multithreading
◼ Threading in C#
◼ Thread Life Cycle
Introduction
◼ Performing operations concurrently (in parallel)
❑ We can walk, talk, breathe, see, hear, smell... all at the
same time
❑ With threads Computers can do this as well - download
a file, print a file, receive email, run the clock, more or
less in parallel….
3
What is a Thread?
◼ Thread: is the fundamental unit of execution.
◼ Thread allows the program to run tasks in parallel
◼ Thread may be managed by the operating system or by a
user application
◼ More than one thread can be executing code inside the same
process (application).
4
Threads vs Processes
◼ What’s the difference between a process and a thread?
❑ Processes run in parallel on a computer, while threads run in
parallel within a single process.
❑ Processes have their own memory space, whereas threads
share memory.
❑ Processes are fully isolated from each other; while threads have
just a limited degree of isolation.
❑ Hence processes are “heavyweight” while threads are
“lightweight”
5
Process Model
❑ A process is a sequential program in execution.
❑ Process components:
❑ The program (code) to be executed. Code Data
❑ The data on which the program will execute. Process Status
Resource
❑ Resources required by the program.
❑ The status of the process execution.
❑ A process runs in an abstract machine Abstract Machine Environment
environment (could be OS) that manages the
sharing and isolation of resources among the
community of processes.
6
Thread Model
❑ In the thread model:
❑ Each thread is associated with a process.
❑ A thread is an entity that executes by relying on the
code and resources, holding by the associated
Resource
process.
❑ Several threads could be associated with a single Process Thread
process. Those threads share the code and resources Data Code Data
of the process. Process Status Thread Status
❑ A thread allocates part of the process’s resources for
its needs.
❑ A thread has its own data and status.
7
Why do we need threads?
◼ To enhance parallel processing
◼ To increase response to the user
◼ To utilize the idle time of the CPU
◼ Prioritize your work depending on priority
Why should we use threads?
Performance
Perceived
performance
Simplify coding
Multithreading
◼ The process of executing multiple threads simultaneously is
known as multithreading.
◼ The main purpose of multithreading is to provide simultaneous
execution of two or more parts of a program to maximum
utilize the CPU time.
◼ A multithreaded program contains two or more parts that can
run concurrently. Each such part of a program called thread.
10
Example
◼ Consider a simple web server
❑ The web server listens for request and serves it
❑ If the web server was not multithreaded, the requests
processing would be in a queue, thus increasing the response
time and also might hang the server if there was a bad request.
❑ By implementing in a multithreaded environment, the web
server can serve multiple request simultaneously thus
improving response time
Multitasking vs Multithreading vs Multiprocessing vs parallel
processing
◼ Multitasking: Ability to execute more than one task at the same time is
known as multitasking.
◼ Multithreading: It is a process of executing multiple threads
simultaneously. Multithreading is also known as Thread-based
Multitasking.
◼ Multiprocessing: It is same as multitasking, however in multiprocessing
more than one CPUs are involved. On the other hand one CPU is
involved in multitasking.
◼ Parallel Processing: It refers to the utilization of multiple CPUs in a
single computer system.
12
An example of multithread
13
Threads Concept
Multiple Thread 1
threads on
Thread 2
multiple
Thread 3
CPUs
Multiple Thread 1
threads
Thread 2
sharing a
Thread 3
single CPU
14
Advantages of Multithreading
◼ More responsive to user input – GUI application can interrupt
a time-consuming task.
◼ Server can handle multiple clients concurrently
◼ Can take advantage of parallel processing.
15
Threading Namespace in C#
◼ Threading Namespace in C#
❑ System.Threading
◼ Consists of classes for synchronizing thread activities.
Thread Class
◼ In C#, Threads are managed by the:
System.Threading.Thread class.
❑ C# threads are passed a static or instance function of some C# class
using a standard delegate of type “ThreadStart”.
Starting C# Threads
1) Creates a thread object
❑ Thread thread = new Thread(new ThreadStart(ThreadFunc));
◼ ThreadStart delegate identifies the method that the thread executes when it starts.
◼ ThreadFunc can be: Static or instance member of the class instance that created the thread
2) starts the thread
◼ thread.Start();
Example using System;
using System.Threading;
namespace threadApp
{
public delegate void ThreadStart();
class Program
{
static void Work1(){
Console.WriteLine("Start");
}
static void Main(string[] args){
// Delegate instance
ThreadStart dt= new ThreadStart(Wordk1);
// Thread instance
Thread t1 = new Thread(dt.Invoke);
t1.Start();
Console.ReadKey();
}}}
19
Thread Life Cycle
◼ The life cycle of a thread starts when an object of the System.Threading class is created and
ends when the thread is terminated or completes execution.
◼ Following are the various states in the life cycle of a thread:
❑ The Unstarted State: It is the situation when the instance of the thread is created but the
Start method is not called.
❑ The Ready State: It is the situation when the thread is ready to run and waiting CPU
cycle.
❑ The Not Runnable State: A thread is not executable, when:
◼ Sleep method has been called
◼ Wait method has been called
◼ Blocked by I/O operations
❑ The Dead State: It is the situation when the thread completes execution or is aborted.
Thread lifecycle
Running Suspended
Unstarted Aborted
WaitSleepJoin
Example: without using threads using System;
using System.Threading;
namespace threadApp
{
class Program
{
static void Work1()
{
for(int i = 1; i <=10; i++)
{
Console.WriteLine("Work 1 is called " + i.ToString());
}
}
static void Work2()
{
for (int i = 1; i <= 10; i++)
{
Console.WriteLine("Work 2 is called " +
i.ToString());
}
}
static void Main(string[] args)
{
Work1();
Work2();
Console.ReadKey();
}
}
}
Output
Example: with using threads using
using
using
System;
System.Collections.Generic;
System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
namespace threadApp
{
class Program
{
static void Work1()
{
for(int i = 1; i <=10; i++)
{
Console.WriteLine("Work 1 is called " + i.ToString());
}
}
static void Work2()
{
for (int i = 1; i <= 10; i++)
{
Console.WriteLine("Work 2 is called " + i.ToString());
}
}
static void Main(string[] args)
{
Thread t1 = new Thread(Work1);
Thread t2 = new Thread(Work2);
t1.Start();
t2.Start();
Console.ReadKey();
}
}
}
Output
