About Synchronization concept of static and non static method using Class level lock

[Ritesh Somani]

Please go through from following code and help me out in Synchronization concept.
Q1. from Class level lock can we able to call non static synchronized method simultaneously ?
Q2. If more than 1 threads are running then they can operate on same static synchronized method simultaneously ?
Q3. From class level lock can more than 1 threads able to execute non static synchronized method ?
Please give me reply......

class ThreadDemo8 extends Thread
{
	static ThreadDemo8 t1,t2,t3;
	synchronized static void m1()throws InterruptedException
	{
		for (int i=0;i<5 ;i++ )
		{
			System.out.println(i);
		}
		Thread.sleep(5000);
		System.out.println("Inside m1()"+t1.getState()+"  "+t1.getName());
		System.out.println("Inside m1()"+t2.getState()+"  "+t2.getName());
		System.out.println("Inside m1()"+t3.getState()+"  "+t3.getName());
	}


	/*synchronized static void m2()throws InterruptedException
	{
		for (int i=0;i<10 ;i++ )
		{
			System.out.println(i);
		}
		Thread.sleep(5000);
		System.out.println("Inside m2()"+t1.getState()+"  "+t1.getName());
		System.out.println("Inside m2()"+t2.getState()+"  "+t2.getName());
		System.out.println("Inside m2()"+t3.getState()+"  "+t3.getName());
	}*/


	synchronized void m3()throws InterruptedException
	{
		for (int i=0;i<5 ;i++ )
		{
			System.out.println(i);
		}
		Thread.sleep(5000);
		System.out.println("Inside m3()"+t1.getState()+"  "+t1.getName());
		System.out.println("Inside m3()"+t2.getState()+"  "+t2.getName());
		System.out.println("Inside m3()"+t3.getState()+"  "+t3.getName());
	}
	public void run()
	{
		try
		{
			m1();
			//m2();
			this.m3();	
		}
		catch (InterruptedException e)
		{
		}
		
		

	}
	public static void main(String[] args) throws InterruptedException
	{
		t1=new ThreadDemo8();
		t2=new ThreadDemo8();
		t3=new ThreadDemo8();
		t1.start();
		t2.start();
		t3.start();
		System.out.println(t1.getState()+"  "+t1.getName());
		System.out.println(t2.getState()+"  "+t2.getName());
		System.out.println(t3.getState()+"  "+t3.getName());

	}
}

Thanks & Regards
-Ritesh R Somani

[Henry Wong]

Please QuoteYourSources.

[Helen Ma]

Basically, synchronizing a non-static method means synchronize(this) where this is the instance that calls the method. That means this instance is locked by one thread at a time.
Synchronizing a static method means synchronizied (ThreadDemo8.class), or any other class object. That means this class object is locked by one thread at a time.
One thread can lock the class object while another thread can lock the instance.

So, if two threads access the same object such as ThreadDemo8, the non-static syn method and static syn method can be accessed concurrently by these two threads. One thread runs on the non-static method while another thread runs on the static method.

But the same non-static method or the same static method cannot be accessed concurrently. For example, one thread runs m1(), another thread cannot run m1() at the same time.

Correct me if I am wrong.

[Ritesh Somani]

Thanks a lot for helping me out...!

Good Day

Thanks and Regards
-Ritesh Somani