11 iec t1_s1_oo_ps_session_16

Object-Oriented Programming Using C#
Objectives

In this session, you will learn to:
Implement multiple threads
Identify the thread priority
Use synchronization in threads
Identify communication between processes
Declare delegates
Instantiate delegate

Ver. 1.0 Session 16 Slide 1 of 31

Demo: Hangman Game

Problem Statement:
The next door children request you to create the Hangman
game for them. The game asks a user to enter a category as
Book or Movie. Based on the category, a book name or movie
name is extracted and the user is asked to guess the name by
giving the character and its position in a string. A user will get
60 seconds to play the game.
Develop the Hangman game application.


Demo: Hangman Game (Contd.)

Solution:
To solve the preceding problem, you need to perform the
following tasks:
1. Identify the data source where the name of the book or movie is
stored.
2. Create a console-based application for the Hangman game.
3. Build and execute the application.


Introducing Multithreading

Multithreading helps to perform various operations
simultaneously and saves users’ time.
Multithreading allows you to achieve multitasking in a
program.
Multitasking is the ability to execute more than one task at
the same time.
Multitasking can be divided into the following categories:
Process-based multitasking
Thread-based multitasking

Let us understand multithreading with the help of an
example.



A lady is working on a computer.



The lady is eating an apple, reading a book, and working on a
computer simultaneously.


Advantages of Multithreading

The advantages of multithreading are:
Improved performance
Minimized system resource usage
Simultaneous access to multiple applications
Program structure simplification


Limitations of Multithreading

The limitations of multithreading are:
Race condition
Deadlock condition
Lock starvation


Creating Multiple Threads

• You can create multiple threads in a program by extending
the Thread class.


Identifying the Thread Priority

One of the attributes that controls the behavior of a thread is
its priority.
The .NET Runtime Environment executes threads based on
their priority.
The threads are fixed-priority scheduled. Each thread with
its priority has its position in the thread queue of the
processor.


Defining Thread Priority

Thread priority is the property that specifies the priority of
one thread with respect to the priority of another thread.
Thread priority can be defined as:
– Above normal
– Below normal
– Highest
– Lowest
– Normal
A thread with higher priority runs before threads, which
have lower priority.
If C# encounters another thread with higher priority, the
current thread is pushed back, and the thread with the
higher priority is executed.


Setting the Thread Priority

• You can set the thread priority after it is created using the
Priority property of the Thread class.
• The following syntax shows how to set the thread priority:
NewThread.Priority =
ThreadPriority.Highest;


Setting the Thread Priority (Contd.)

NewThread.Priority = ThreadPriority.Highest
ThreadPriority.Highest; Property
Specifies the new
priority setting for a
thread


Setting the Thread Priority (Contd.)

If multiple threads with the same priority are available, the
scheduler cycles through the threads in that priority, giving
each thread a fixed time slice in which to execute.
As long as a thread with a higher priority is available to run,
lower priority threads do not get to execute.
When there are no more runnable threads at a given
priority, the scheduler moves to the next lower priority and
schedules the threads at that priority for execution.


Using Synchronization in Threads

In a multithreaded application, when threads need to share
data with each other, the application should ensure that one
thread does not change the data used by the other thread.
C# enables you to coordinate the actions of multiple threads
by using synchronized methods or synchronized
statements.


Synchronizing Threads

• Synchronization of threads ensures that if two or more
threads need to access a shared resource then that
resource is used by only one thread at a time.
• You can synchronize your code using the synchronized
keyword.
• Synchronization is based on the concept of monitoring. A
monitor is an object that is used as a lock to the data
members and methods of a class.


Synchronizing Threads (Contd.)

The following figure shows how synchronization is
maintained among threads.


Locking Code Using the Monitor Locks

• The System.Monitor class enables you to serialize the
access to blocks of code by means of locks and signals.


Using Monitor Locks with the C# Lock Statement

• The other way to lock code is by using the C# lock
statement.
• Although the C# lock statement does not support the full
array of features found in the Monitor class, it enables you
to obtain and release a monitor lock.
• To use the lock statement, simply specify the lock statement
with the code being serialized in braces.
• The braces indicate the starting and stopping point of code
being protected.


Communication Between Processes

A process is a running instance of a program.
The communication between the processes at run time
within the same computer or over a network is called the
interprocess communication.
To allow communication between various processes with a
unique address space, the operating system's kernel acts
as the communication channel.


Application Domain

In .NET, threads execute in an application domain. A thread
in one process cannot invoke a method in a thread that
belongs to another process.
In .NET, however, threads can cross the application domain
boundaries, and a method in one thread can call a method
of another application domain.
The application domain is a logical process inside a
physical process.


Application Domain (Contd.)

The following figure shows application domains interacting
with each other.


Application Domain (Contd.)

• The main purpose of application domain is to isolate your
applications from other applications.
• Application domains run on a single process.
• You use the System.AppDomain class to manage
application domains.


Introducing Delegates

Delegates in C# allow you to dynamically change the
reference to the methods in a class.
A delegate is a reference type variable, which holds the
reference to a method.
Delegates are a general-purpose mechanism for indirectly
calling methods at runtime. Primary use of delegates in C#
programming is for implementing events and the call-back
methods.
To implement delegates in your application you need to
declare delegates, instantiate delegates and use delegates.


Declaring Delegates

The methods that can be referenced by a delegate are
determined by the delegate declaration.
The delegate can refer to the methods, which have the
same signature as that of the delegate.


Declaring Delegates (Contd.)

Following is the syntax of delegate declaration:
delegate<return type><delegate-
name>(<parameter list>)


Instantiating Delegates

Assign the address of the required method to the delegate
object.
This can be done by calling the constructor of the delegate
class and passing the method name.


Instantiating Delegates (Contd.)

The following example shows how to assign the address of
a method to a delegate variable:
public void DelegateFunction(string
PassValue)
{
// Method implementation Here
}
//Delegate Declaration
public delegate void MyDelegate(string
ArgValue);
public void UseMethod()
{
//Delegate Instantiation
MyDelegate DelegateObject = new
MyDelegate(DelegateFunction);
}

Summary

In this session, you learned the text format would be
All the information stored in that:
displayed on of screen as text.
The types a multitasking are:
This means 'A' will be written as 'A' in the files.
• Process-based multitasking
• Thread-based multitasking
Similarly, the number –12345.678 will be written as the
string "-12345.678". multithreading are:
The advantages of
• Improved performance
This means that you can directly display the contents of the
• Minimized system resources usage
file on the screen. access to multiple applications
• Simultaneous
The limitations of multithreading are:
Race condition
Deadlock condition
Lock starvation


Summary (Contd.)

– The System.Threading the text format would be
All the information stored in class is used to construct and
displayed on a screen as text. multithreaded application.
access individual threads in a
– Thread priority is the property that in the files.
This means 'A' will be written as 'A'specifies the priority of one
thread with respect to the priority of another thread.
Similarly, the number –12345.678 will be written as the
– Synchronization of threads ensures that if two or more threads
string "-12345.678".shared resource then that resource is used
need to access a
This means that you at a time.
by only one thread can directly display the contents of the
file on the screen.
– The System.Monitor class enables you to serialize the
access to blocks of code by means of locks and signals.
– The communication between processes at runtime within the
same computer or over a network is called interprocess
communication.


Summary (Contd.)

All the informationdomain is athe textprocess inside abe
The application stored in logical format would physical
displayed on a screen as text. the application domain is to
process. The main purpose of
isolate your applications from the other applications.
This means 'A' will be written as 'A' in the files.
Delegates allow you to write code that can dynamically change
Similarly, the numbercalls.
the methods that it –12345.678 will be written as the
string "-12345.678".
This means that you can directly display the contents of the
file on the screen.


11 iec t1_s1_oo_ps_session_16

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (7)

Similar to 11 iec t1_s1_oo_ps_session_16

Similar to 11 iec t1_s1_oo_ps_session_16 (20)

More from Niit Care

More from Niit Care (20)

Recently uploaded

Recently uploaded (20)

11 iec t1_s1_oo_ps_session_16

Editor's Notes