Part 93 Protecting shared resources from concurrent access in multithreading Video Lecture | C sharp: Enhance your Skills (English) - Back-End Programming

sparked 93 of c-sharp tutorial in this
video we'll discuss what happens if
shade resources are not protected from
concurrent access in a multi-threaded
program and how to protect shade
resources from concurrent access so what
happens if shared resources are not
protected from concurrent access in a
multi-threaded program the output or
behavior of the program can become
inconsistent let's understand this with
an example within this program class we
have this total field at the class level
and within this add 1 million method we
are adding 1 million to that total field
within the main method we are invoking
add 1 million three times and finally we
are printing the value that is present
within the total sphere so this is not a
multi-threaded program it's a
single-threaded program so when we
execute this program the execution is
going to start within the main method so
by default we're gonna get one thread
for free that is the UI thread and that
single thread is going to execute all of
this code so here concurrency is not an
issue and protecting shared resources is
not a concern I have this exact same
code within Visual Studio so let's go
ahead and build this solution and let's
open this project folder within Windows
Explorer let's navigate to the bin and
debug directly that's where we have the
project executable now let's copy this
path and let's try to run this program
from the visual studio command prompt so
here I have Visual Studio command prompt
so let's change the directory to the
directory way we have the project
executable and then the project
executable is threading example dot exe
so let's go ahead and run this 5 times
and notice that all the 5 times we get
the same output that is 3 million and
that's what we expect the program to
print because this add 1 million method
you know is going to add 1 million to
that total view we call it 3 times so
the total should be 3 million and that's
what this program is printing ok all
right now let's rewrite this program to
use multiple threads so here we are
creating 3 threads and each thread is
calling add 1
million okay and then on each of the
threats we are calling start method and
we're also calling join method so why
are we calling join method because we
want the UI thread to wait you know
until all the three threads complete so
that this total field is updated and
then the UI thread can go ahead and
print the value that is present within
the total field okay so let's go ahead
and change the code that we have here so
we need to bring in system door
threading namespace so let's go and do
that first and then let's create a
thread class instance let's call it t1
equals new thread and we want this
thread to execute add 1 million method
so let's go ahead and create three
instances of the thread class and then
let's invoke start method on all of the
three threads let's invoke join method
again on all of the three threads all
right now let's build the project so now
this program is a multi-threaded program
let's navigate to issues to the command
prompt let's clear the screen and let's
execute look at that we get 3 million
that's right let's run it once again
look at that we get a different number
now we get 3 million 3 million 3 million
but look at this every time we run that
we are not getting three million always
we are getting a different number every
time we run on it okay so why is that
inconsistency okay that the inconsistent
output is basically because the total
field is a shared resource here and it
is not protected from concurrent access
by these multiple threads okay and this
operator right here a total plus plus
you know the plus plus operator this is
not thread safe
and that's why we have that inconsistent
or put every time we run this program
okay and there are several ways to fix
this and I have you know discussed here
two of the options one option is to use
the interlocked class and this place has
got increment method which is going to
increment a specified variable value and
store the result as an atomic operation
okay so we are going to change the code
that is present with an add 1 million
function from total plus plans to
interlock dot increment and and parse
our field that we want to be updated as
an atomic operation in this case the
total field again we need to pass it as
a reference parameter so that it gets
updated okay so let's change that to
that and see if it works as expected so
interlocked dot increment and let's pass
our total field that's it so let's build
a project let's navigate visuals to the
command prompt that's actually clear the
screen and let's run look at this every
time we run it no matter how many times
we run it we get the same output okay
three million so the program is now
working as expected so one option is to
use the interlocked class the other
option is to basically use locking okay
create a lock object and then lock the
section which updates that field so here
this is the section that is updating the
field so when we use this lock only one
thread that can enter that piece of code
so that you know the field is correctly
updated so let's go ahead and use that
instead of interlocked dot increment
method and see if it works as expected
so the class level let's create a static
object
and maybe let's call it lock equals new
object and then you know here it is
total plus plus so let's actually change
it to use the lock so log of log and
then let's build a solution let's clear
the screen
let's run five times and notice that we
get the same output okay so basically to
fix this there are several issues and we
have explored two of the I mean two of
the options here one is interlock dot
increment and the other one is basically
locking okay now which one of these
options is better okay from a
performance perspective using
interlocked class is better over using
locking okay let's actually measure the
performance and to do that I'm actually
going to write some code here and to do
that we need to use system door
diagnostics namespace so let's go and
bring that n system Diagnostics and let
this class called stopwatch let's call
it stop watch equals stopwatch dot start
now so when this program begins
execution we are starting a stopwatch
and then when it prints the total we are
going to stop it and then finally we
will print the elapsed time so they have
this stopwatch object and there is this
property elapsed milliseconds actually
let's use elapsed the ticks so what does
it take it take is again a measurement
of time basically one millisecond
contains 10,000 takes ok so basically if
you want to know how many ticks are
there in a second or an hour
there's
another class that you can use so
consult a trade line so there is this
time span object and this time span
object has got you know these enum
values here ticks per day
ticks per hour ticks per millisecond you
know you can use those to find out how
many ticks are there in a second or a
millisecond basically alright so at the
moment we are using locking method to
protect you know the shared resources
and let's see what is the time we get
let's build this project let's navigate
to the command prompt and let's execute
the command look at that that is the
time it has taken you know three two
three three four let's run it once more
okay something like two nine three seven
two five let's run it three times so
around 200 to 300 ticks I mean not
hundred it's more than that but you know
those many ticks are taken to complete
this program and we are using the lock
object now instead of the lock object
let's use in the lock that increment
method and see what time it takes to do
that let's get rid of that one and let's
say in the lock dot increment
let's pass ref and the name of the field
is total right let's build this relation
so that is with locking now let's run
once again
look at that it's much lesser with
interlocked class okay so for my
performance perspective using
interlocked class is better over using
locking locking locks out all the other
thread except a single thread to read
and increment the total variable so this
will ensure the total variable is
updated safely but the downside is that
since all the other threads are locked
out there is a performance head but keep
in mind the interlock the class can only
be used with addition subtraction
you know on an indoor a long field but
if it anything else other than that then
probably we'll have to resort to using
locking mechanism okay
the interlocked class again has methods
for incrementing decrementing adding and
reading variables atomically and this is
the code that we have seen you know to
basically get the time in ticks and we
have also seen that the timespan object
can be used to find out how many ticks
are there in a second or in a
millisecond that's it for today thank
you for listening have a great day