Locking doubt : Thread calling a method on an instance even if another thread has a lock on it.

[ashvinyin bhawalkar]

Locking concept doubt: Thread calling a method on an instance even if another thread has a lock on that same instance ?

I have a Student class with 2 non-static methods, one synchronized and another non-synchronized method.
I am creating 2 threads (Thread_A & Thread_B) using the same instance of the Student class.
Thread_A will always call the synchronized method and Thread_B will always call the non-synchronized method.

Suppose Thread_A starts before Thread_B and enters the synchronized method. Now Thread_A has acquired a lock on the instance of the Student class and will not realease it untill it finishes the execution. My doubt is that even if the Thread_A has a lock on the student instance, why Thread_B is able to call the Non-Sync method on the same student instance before Thread_A releases the lock on that instance.

Why locking works only if both methods are synchronized.

class Student implements Runnable{
	
	public void run(){
		//check which thread starts first
		System.out.println(Thread.currentThread().getName()+" : started.");
		
		if( Thread.currentThread().getName().equals("Thread_A") )
			this.mySynchronizedMethod(); // Thread_A will always call sync method
		else
			this.myNonSynchronizedMethod();	// Thread_B will always call non-sync method		
	}
	
	public synchronized void mySynchronizedMethod(){
		for(int i=0;i<20;i++){
			try{
				System.out.println(i+":"+Thread.currentThread().getName());
				Thread.sleep(1000);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
			
	}
	
	public void myNonSynchronizedMethod(){		
		for(int i=0;i<20;i++){
			try{
				System.out.println(i+":"+Thread.currentThread().getName());
				Thread.sleep(1000);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
	}
}

public class MyClass {
	public static void main(String[] args) {
		//create a Student instance
		Student s = new Student(); 
		
		//create 2 threads using the same student instance
		Thread ta= new Thread(s,"Thread_A");
		Thread tb= new Thread(s,"Thread_B");
		ta.start();
		tb.start();
	}
}

Output:

Thread_A : started.
0:Thread_A
Thread_B : started.
0:Thread_B
1:Thread_A
1:Thread_B
2:Thread_A
2:Thread_B
3:Thread_B
3:Thread_A
4:Thread_B
4:Thread_A
5:Thread_B
5:Thread_A
6:Thread_B
6:Thread_A
7:Thread_B
7:Thread_A
8:Thread_B
8:Thread_A
9:Thread_A
9:Thread_B
10:Thread_B
10:Thread_A
11:Thread_B
11:Thread_A
12:Thread_B
12:Thread_A
13:Thread_A
13:Thread_B
14:Thread_A
14:Thread_B
15:Thread_B
15:Thread_A
16:Thread_B
16:Thread_A
17:Thread_B
17:Thread_A
18:Thread_B
18:Thread_A
19:Thread_B
19:Thread_A

[Balasubramanian Bhaskaran]

For executing non-synchronized method, lock is not needed. So irrelevant of who owns the lock, the non synchronized method will be executed, and no thread safety is guaranteed on that method.

[ashvinyin bhawalkar]

So you mean non-sync methods will run even if there is lock on that instance ?

[Balasubramanian Bhaskaran]

Yes, exactly

[Ram Narayan.M]

Synchronizing is done if the method has some code to access critical common resource which should not be spoiled by multiple thread running on that method concurrently.

Unsynchronized does not deal with that critical common resource so no danger of multiple threads accessing that method concurrently.

So, its legal to allow thread running on Unsynchronized method on an instance even if that instance has been locked by another thread.

[ashvinyin bhawalkar]

Thanks a lot for you time.