Synchronization concept in Java

Please follow the below links of YouTube for the following:

All these are 2 minute videos. Please watch all of them.


VERY IMPORTANT CONCEPT ABOUT SYNCHRONIZATION:


Whenever, we think about locks: just remember 2 things
-> Lock at the CLASS LEVEL(static methods)
-> Lock at the INSTANCE LEVEL (non-static methods)

1) Consider two objects on a class. Both the objects belong to the SAME INSTANCE of the class.
i.e. Animal a1=new Animal();
     Animal a2=a1;
     
     Both objects a1 and a2 belong to the same instance of the Animal class.
2) The class Animal contains 4 non-static synchronized methods, 4 static synchronized methods and 4 non-synchronized methods.
3) If two threads are created such that Thread1 has object a1
   and Thread2 has object a2.
4) Then if Thread1 starts before Thread2. Then Thread1 will acquire locks for all the synchronized methods,
   hence Thread2 cannot enter in any of the synchronized methods of the class, even if Thread 1 wants to 
   execute in only 2 synchronized methods, but not all synchronized methods, but still all synchronized methods
   will be locked by object a1 which belongs to Thread1. But Thread2 can enter in non-synchronized methods of the class.
   Thread2 cannot enter in any of the synchronized methods of the class.
5) But if a1 and a2 are different instances of the class Animal such that:
   Animal a1=new Animal();
   Animal a2=new Animal();
       Thus, a1 and a2 are different instances of Animal class.
       In this case, if Thread1 which has object a1 enters in one of the non-static synchronized methods of the
       class, then the Thread2 which has object a2 can enter in other non-static synchronized methods of the class.
       But, if Thread1 enters in static synchronized method of the class, then any of the other static synchronized
       methods of the class can not be accessed by Thread2 even if object1 and object2 are different instance of
       the same class or same instances of the same class.
       This is because, even if a1 and a2 are different instances, but the STATIC keyword acquires lock at the
       class level. Hence no other instances of the object can be allowed in STATIC SYNCHRONIZED methods. 
       But if Thread1 enters in STATIC SyNCHRONiZED methods(that is obtains lock for static synchronized methods)
       then Thread2 which is another instance of the same class Animal can enter(that means obtain lock) for
       STATIC NON-SYNCHRONIZED methods, NON-STATIC(that means INSTANCE) SYNCHRONIZED methods and 
       NON-STATIC(in other words INSTANCE) NON-SYNCHRONIZED methods.
       

Whenever, we think about locks: just remember 2 things
-> Lock at the CLASS LEVEL(static methods)
-> Lock at the INSTANCE LEVEL (non-static methods)
       
Please remember the following IMPORTANT things:
1) A static(Lock is at the CLASS level) synchronized and non-static(Lock is at the instance level that is object level)
will NOT-BLOCK each other EVER. The static methods locks on a CLASS level while the non-static methods 
locks on a INSTANCE level also known as the Object level. These actions DONOT interfere with each other AT ALL.
2) For synchronized blocks, we look at exactly what object has been used for locking. That is we look at the 
parameters of the synchronized methods to check which object is used for locking. Threads that
synchronize on the same objects(same instance of the same class) will BLOCK each other. 
Threads that synchronize on different objects(different instance of the same class) will NOT-BLOCK each other.
3) Methods that give up the locks are: only one methods in entire Java which is:
wait() method defined in Object class.
4) Methods thathold the locks are:
notify() and notifyAll() -> These two methods belong to Object class
join()  -> This method belongs to Thread class
sleep()  -> This method belongs to Thread class
yield()  -> This method belongs to Thread class

Please remember every part of the above explanation. Each and every word from the start of the page to the
end of the page is VERY VERY IMPORTANT.




Threads, synchronized methods and blocks and Lock -> 1) http://www.youtube.com/watch?v=yvLYSXi8U_g
                                                     2) http://www.youtube.com/watch?v=b779xXBDC9w
                                                     3) http://www.youtube.com/watch?v=NDw-KnRNPso
                                                     
volatile keyword -> http://www.youtube.com/watch?v=7BShcgKkVAU