Part 92 Significance of Thread Join and Thread IsAlive functions Video Lecture | C sharp: Enhance your Skills (English) - Back-End Programming

this part 92 of c-sharp tutorial in this
video will discuss the significance of
threaded join and thread dot easily
functions with an example thread or join
blocks the current thread and makes it
wait until the thread on which joined
method is invoked completes join method
also has a overload where we can specify
the timeout if we don't specify the
timeout they calling thread waits
indefinitely until the thread on which
join us invoke the completes this
overloaded join method way we can
specify the timeout returns a boolean
true if the thread has terminated
otherwise false join is particularly
useful when we need to wait and collect
result from a thread execution or if we
need to do some cleanup after the thread
has completed either live returns
boolean true if the thread is still
executing otherwise false let's look at
the usage of these two functions with an
example let's flip to visual studio at a
moment here we have got two static
functions thread one function and thread
two function within the main method
let's actually print a message saying
main started
and then the main function is going to
create a worker that let's call it t1
and let's make this thread execute this
thread one function so program dot
thread one function and then let's start
thread one in a similar fashion let's
create another thread and make that
execute thread to function and finally
let's print this message stating main
completed right let's go and run this
now okay look at the order in which
these messages are printed so first line
is going to be main started and then it
prints thread one function started
that's basically because we created
thread one this thread one is going to
execute that function so it printed that
message there and notice that next we
get main completed and then thread to
function started so what is happening
here now main function here are this
main function you know when we run the
program we get one thread for free
that's our main thread you know that's
going to print this message and then the
main thread is now creating two
additional threads that is thread 1 and
thread 2 so once the main thread creates
an additional threat that is thread 1
and once it starts executing thread 1
function you know the main thread will
not wait for that thread 1 to complete
it will proceed to the next line so here
in the next line it's creating another
thread and then starting that thread
again here at this point the main thread
will not wait for a thread 1 or thread 2
to complete their work you know main
thread once it start starts the worker
threads it's going to proceed by default
to the next line you know in order to
execute that ok
so sometimes you know
we may need to make the main thread wait
while worker threads are doing their
work you know probably because we want
to collect the result you know of the
worker threads and then based on that we
want the main threat to do something so
those are some you know situations where
we want the main thread to wait until
you know the straight one and thread two
completes that's when join is
particularly useful okay so look at this
if I run this program once again you
know we get a different output look at
that main started thread one function
started thread two functions that and
then main completed okay so every time
we run this program these statements are
not guaranteed to be printed in any
particular order okay so that's the
nature of multi-threaded programming so
basically if you want to force the main
thread to wait until these worker
threads complete their execution then
you will have to use join method so now
let's say you know we started thread one
and thread two now if we want to force
this main thread to wait until the third
one and thread to complete all we are
going to do is thread one door join now
you know once this line is executed the
main thread is going to suspend its
execution and wait for thread one to
return from its method okay so once you
know this line has completed its
execution
we know that thread one has returned so
we can basically say thread one function
completed
similarly do you to join now again the
main thread is going to wait under
thread to completes its execution and
returns okay now let's go ahead and run
this now no matter how many times you
run this program you're going to get the
same output so thread one function start
at thread two functions started thread
one function completed thread to
function completed and then main
completed okay so here we are basically
forcing the main thread to wait until
thread 1 and thread to complete by using
the join method right now that's
actually port you know some sleep time
here actually let's make this thread
sleep for 5 seconds so thread dot sleep
and let's specify the time in
milliseconds 5,000 milliseconds it's 5
seconds and let's say thread one
function is about to return ok so
basically that 5 seconds have elapsed
and it's about to return that's what is
the message we're printing here all
right now let's go ahead and run this
and see what what would we get so thread
one function started thread two
functions started so you know the main
thread is waiting for you know thread 1
to complete and then once thread 1 has
completed then you know it it finished
thread - you know that's what is the
message that's printed and then main
completed ok now there is another
overload of this join method way we can
specify the timeout so basically there
are 3 overloaded versions you know the
second overloaded version we can specify
the timeout value in milliseconds so
what is this timeout that's basically
that time that we are willing to wait
until you know the thread completes its
execution so for example here if we
specify thousand milliseconds then the
main thread is going to wait only 4,000
milliseconds that is one second until
the thread one returns
if the red one doesn't return within
that timeout value then the main thread
you know will continue to execute from
the line after that okay and one more
thing to notice here on this overloaded
version wave we can specify the timeout
returns boolean that is true or false so
it returns true in case of the method
has completed execution and if it has
returned otherwise false
so let's basically say if T 1 dot join
you know of thousand milliseconds then
we know that thread 1 function has
completed else let's print a message
saying thread 1 function has not
completed in one second ok so let's go
ahead and run this and see what ought to
be get so look at that thread one
function started thread two functions
started thread one function has not
completed in one second and so it can
continue to the next line thread to
function completed main completed and
then after that you know thread one
function you know came out from sleep
and then you know this message is
basically printed at that point of time
ok all right let's change this function
slightly so here we are saying thread to
function completed but before we say
main completed let's actually check you
know whether if thread 1 is still alive
or not meaning whether if it is still
processing or not so T 1 dot is alive so
basically this method is returning a
boolean and that boolean indicates the
execution status of the current thread
whether if it has been completed or it
is still processing if it is still
processing then it is going to return
true otherwise false so if T 1 dot is
alive we know that thread 1 is still
doing its work so let's actually print a
message saying thread 1 function
is still doing its work else if it's not
alive then we know for sure thread one
has completed so let's print that
message right here let's go ahead and
run this
so thread one function started the two
functions started that one had function
has not completed in one second thread
to function completed and then you know
it checks this ISA live actually
returned false there I mean true there
and as a result thread one function is
still doing its work that's what is the
message printed and then it prints main
completed and then after that line is
printed you know thread one function has
finished its job so it's going to print
that message there thread one function
is about written now let's say we want
to repeatedly you know check whether if
thread one is alive or not maybe every
500 milliseconds and in order to do that
let's actually put this in a for loop so
for and I is equal to one let's say I
less than or equal to ten I plus plus
now if T 1 dot is alive if it is still
alive let's bring this message thread
one function is still doing its work and
then let's make the current thread sleep
for maybe 500 milliseconds okay if it is
not alive meaning it has completed
execution then in that case print this
message thread one function completed
and then maybe break out of the loop
because there's no point in checking we
know that it has completed execution
okay with this change let's go ahead and
run this and see what output we get so
thread one function started to function
started look at this here it's in that
loop it's checking and then look at what
we get thread one function is about to
return thread one function completed and
finally main completed so basically the
idea here is to understand the
purpose of Issa live and threat or join
and we have seen the usage of them with
the help of this example that's it for
today thank you for listening
have a great day