How to do inter thread communication inside static synchronized block

Question

I have a question regarding static synchronized methods and class level locking. Can someone please help me in explaining this example:

class Test
{
    synchronized static void printTest(int n)
    {
        for (int i = 1; i <= 10; i++) {
            System.out.println(n * i);
            try {
                Thread.sleep(400);
            } catch (Exception ignored) {}
        }
    } 
}  

class MyThread1 extends Thread
{
    public void run()
    {
        Test.printTest(1);
    }
}

class MyThread2 extends Thread
{
    public void run()
    {
        Test.printTest(10);
    }
}

public class TestSynchronization
{
    public static void main(String[] args)
    {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
        t1.start();
        t2.start();
    }
}

Question:

When thread t1 is in the middle of loop (inside printTest()) and I want to make it stop the execution and transfer the control to thread t2. Is there any way to do it?

Since we deal with class level lock I believe we cannot use object level wait() and notify() methods here which would release the object level lock. But in case of class level lock, how to release it and give the control to some other waiting thread?

How do we notify a second thread which is waiting for a class level lock held by thread 1 in the middle of execution?

Answer 1

interrupt() can be used here for your requirement.

If your requirement gets change in future and execution of first thread is required after the second thread then remove if(Thread.interrupted()) inside printTest

 class Test {
    synchronized static void printTest(int n) {
        for (int i = 1; i <= 10; i++) {
            if(Thread.interrupted())
                break;
            System.out.println(n * i);
            try {
                Thread.sleep(400);
            } catch (Exception e) {
            }
        }
    }
 }

 class MyThread1 extends Thread {
    public void run() {
        Test.printTest(1);
    }
 }

 class MyThread2 extends Thread {
    public void run() {
        Test.printTest(10);
    }
 }

 public class TestSynchronization {
    public static void main(String t[]) throws InterruptedException {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
        t1.start();
        t2.start();

        t1.interrupt();
        t1.join();
    }

 }

Answer 2

Since we deal with class level lock I believe we cannot use object level wait() and notify()

I try to avoid saying "class level" or "object level." Whenever you use synchronized you are synchronizing on some object. Remember: Test.class is an object: It's the object that contains all of the run-time information that describes the Test class.

When you say "class level locking", what you're really talking about is synchronizing on a global singleton object (the class object), as opposed to "instance level locking" where there may be many different instances of the class that can be independently synchronized.

I want to make it stop the execution and transfer the control to thread t2.

That's not a very useful way to think about threads. You generally don't want a thread in your program to wait for its turn to work on some task: You want it to wait for a task of its own. There will always be some need for threads to coordinate and communicate with each other, but the more you are able to let each thread go off to do its own thing, the better use you will make of them.

Rather than think of "transferring control" from one thread to another, you want each thread to be in control of its own thing, all the time.

How do we notify a second thread which is waiting for a [...] lock?

There is nothing that can release a thread from waiting to enter a synchronized block. That's one of the limitations of synchronized, and that's one of the reasons why it's a bad idea for any thread to ever stay in a synchronized block for any longer than it takes to update a few fields.

I want to make it stop the execution

The simplest way to get the attention of a looping thread is to have the thread check the value of a volatile boolean variable each time around the loop.

volatile boolean timeToStop = false;

MyType myMethod(...) {
    while (! timeToStop) {
        ...
    }
}

Then, any other thread can set timeToStop=true; in order to get the first thread's attention.

Answer 3

From your comment:

There is one thread (t2)waiting on a class level lock held by another thread (t1). So is it possible for t1 thread to notify thread t2 before t1 exits from the static synchronized method.

Yes, classes are objects, just call notify().

class Test
{

   synchronized static void printTest( int n )
   {
      for( int i = 1; i <= 10; i++ ) {
         System.out.println( n * i );
      }
      try {
        Test.class.notify();     // just use a class literal
      } catch( Exception ignored ) {
      }

   }
}