Java Essentials - Multithreading by reunnable interface

Multi-threading by runable interface

So in the previous video we have discussed multi-threading by extending the thread class

So whenever we are trying to implement one multi-threading environment, we are having two options

We can either extend the respective thread class or we can implement the runable interface

In the runable interface, we are having only one method to implement and that is the run

So whenever we are going to have the multi-threading environment, implementing this runable interface, we are bound to define the run method

So let us go for further discussion. So how to use the runable interface

Without creating a subclass of the thread class, we can also create a thread by implementing the runable interface

For this case also, we need to redefine the run method. and write the code for the thread

So we know that run method is that very method within which you are writing the code

which is the task of the thread to be executed. After creating the class

we need to define the object of the thread class and in the constructor

and we need to pass our created class and use the start method to run the thread So this is the basic concept if I want to have the multi environment using the runable interface

So let us go for one practical demonstration on this concept and that will clear your all doubts

In this program we are going to define one third class implementing runable interface

So you know that in case of runable interface we're having one unimplemented method that is a run

So if you write one class, say, if you go for the implements runable and then if you put this opening and closing

braces you see here we are having on option that is the add unimplemented

method otherwise I can make this class abstract here so if you go for this

add an implement implemented method option you can find that this a run

method it is supposed to get implemented so similarly we did the same here so here

our class name is my thread class which implements runable and which is

overriding this run method we are writing the body for this run method and

within this body I will be ranging from 0 to 9 and we are going to print this

thread dot current thread dot get ID and the respective value of I so in this way

the respective run function body we have defined here so the trade its respective get ID with return the ID of the thread and that will get printed so within the class that

the trade with runable so this the name of the class is thread with runable

so here we're defining the main function we're defining this trade class

objects thread one and thread two and they are getting instantiated using this

my thread class objects actually we are creating the thread object with the my thread class object so in

this way you have defined this thread one and thread two so now if we call this

start and fun methods from this thread one and from the thread two to

thread class objects then this run function will be executed and within this

main function we're having the fall loop where I will be ranging from 0 to 9

and main thread colon line colon I will get printed so let us go for the

execution for the better understanding you can find that here this main thread line number 0 1 2 3 4 5 6 7 8 9 and then

for this particular thread ID it is getting printed as a 10 and 11 for the 2

objects that is a thread 1 and 3 so you can find that thread number 11 for this we

are having this line 0 11 line 1 11 line 2 11 line 3 but having this 11 line 9 here so respective i value is ranging from 0 to 9 similarly for thread number 10 we having the 0 we having this 1 and similarly

we're having this thread number 10 there is the ID it is getting printed and line

number 9 that means I here also the eye is ranging from 0 to 9 so just look at this

outcome look at this output the sequence in which it has got generated so that

means we are finding that this thread one dot method is actually calling this

run function and this trade two dot start this particular function calling is

actually calling the run function and also the main function all these three

functions are in execution in parallel so that's why you are finding that all

these lines are getting printed one after another in a mixed up way so if I

execute my program once again you can find that the sequence of this

execution and this line printing will be changed you can find that you see it has got printed in some different sequence if I go for execution

again it has got printed in some different sequence you see different times

different sequences are coming so that will depend upon the execution synchronization

in which order all these three that is a main thread and two threads that is

our object's names are respective thread one and three two how they are

executing within this machine and that's why the outcome is changing along with the execution

Thanks for watching this video