Java Essentials - Thread synchronization

In this video we are discussing thread synchronization

Whenever multiple threads will be operating in our system, then they might be demanding

the same shareable resource. And it is a problem known as the critical section problem

So in case of critical section when the multiple threads are demanding the same shareable

resource, there is the same shareable database, same shareable file, same shareable, some other

I.O. resources. Then in that case, if we don't have to do that, we don't have to be able to be able to shareable, the same shareable

don't have any synchronization that which thread will be accessing which one earlier or later

then obviously some mal results may get produced so this thread synchronization is a very serious

problem so how to do this straight synchronization will be discussing that one in our section

today so synchronization means we are putting some ordering in the multi-threading environment

execution. So why we should synchronize threads? When we start two or more threads

within a program there may be a situation when multiple threads try to access the

same resource and finally they can produce an improper result due to concurrency issues So due to some not maintaining the synchronization between the threads it may produce some

incorrect result for us. So we can easily synchronize the tasks in Java by using the keyword or the using the block

that is known as the synchronized block. And every object in Java is associated with a concept that, that is known as the monitor

The monitor is used to control the access of the resources at a given point in time

So monitored is nothing but which will actually monitoring that how the resources will get allocated to the respective processes

So to have the better idea on this thread synchronization, let us go for one practical demonstration where it will be discussing this topic with one sample code

In this program, we are defining one class, the name of the class is transferred

it is having only one method that is a send message so this is a method we're having

so this method is a very simple method it is having one string to get printed and then

it will wait for one second delay for one second so that why we have put this 1 000 milliseconds as an input argument to this slip method which is public static void sleep long millies which throws interrupted exception we have discussed that one in the earlier

videos also that's why we put it's put it under the tri block and catch block is handling

this interruptive exception so e. print stack dress so the respective body for this catch block

is this one after after waiting for say one second of duration then this message is

sent message concatenation is sent this particular string will get printed now

here we're having one class the name of the class is message transfer which

extends thread so as it is extending thread so here we can write the

word the method that is run here message transfer is the respective constructor

it is having one private string message and transferred object that is a

transfer class object here you can find that here we have defined the transfer

transfer class so transfer class object message transfer message transfer is nothing but the constructor of this class that is the message transfer which

takes this string message and transfer object trans as input argument to

instantiate this instance variables within the class transfer message transfer and here as this particular class is extending thread class so that why we overriding the run method here and

here you have used the synchronized message transfer you can find that this

message transfer is nothing but the transfer class object and synchronous message

transferred within this synchronous block we have right we have written we have

called this method there is a message transfer dot send message that means

we have called this method under the synchronized block so what will happen when we will be having multiple objects

under this message transfer class and when for all of them will be calling the

start method okay let me discuss this one I think that will clear your conception

so public class sync thread so this is a class we have defined under this

we're having the main function and we have here we have defined one transfer class

object that is a transfer trans is a new transfer and message transfer objects

that means this class objects were defining so that we can we can call the start

we can call the start method which will call in turn the run method here so that's

why message transfer message one is the new message transfer what is this this is

the respective message and this is the transfer class object you can find that we

defined that respect