wait+ interruptedException

[kumarth ravi]

Thank you,

I will give one scenario .

    
 
 class SharedResource {
 
  public synchronized void gotoWaitState() {
       try {
          wait();
       } catch(InterruptedException e) {  // here my    doubt
                                           //
          }
   }
    public synchronized void comeFromWaitState() {
        notify();
    }
 

  }
 
  class WaitStateThread implements Runnable {
     SharedResource  ob2;
     public WaitStateThread (SharedResource  x) {
        ob2=x;
      }
      public void run() {
        ob2.gotoWaitState();
      } 
  }
 

 
  
   class ReleaseThread implements Runnable {
     SharedResource  ob2;
     public ReleaseThread(SharedResource  x) {
        ob2=x;
      }
      public void run() {
        ob2.comeFromWaitState();
      } 
  }
 
  public class CallThread {
 
   public static void main(String[] args) {
       SharedResource  ob1 =new SharedResource ();
        
        Thread t1=new Thread(new WaitStateThread(ob1)); 
           t1.start();
        Thread t2=new Thread(new ReleaseThread(ob1));
           t2.start();
   }
 
  }

My question is
---------------

Two threads
a)WaitStateThread gets lock on the shared resoucre and by executing wait it goes to waiting state.

b) ReleaseThread, it releases the thread(t1) the from the waiting queue,by executing the method.

now what is the role of InterruptedException ,in above program t1 ,t2 and
main thread is there,so who will generate the interruptedException.

Can you give clear explantion on that.

[Ernest Friedman-Hill]

In this program, there won't be any InterruptedExceptions. If another thread called t1.interrupt() during the wait() call, then you's get one.

Moving to our Threads and Synchronization forum.

[Nicholas Jordan]

What about this scenario ?

package demo;
 
/*
 *  Demonstrate the role of InterruptedException.
 */
 
public class InterruptedExample  implements Runnable 
{
    public void run() 
    {
        /**
         *  This method causes the current thread  
         *  to place itself in the wait set for this object 
         *  and then to relinquish any and all synchronization claims on this
         *  object.
         */
        try
        {
            wait();
        }
        catch(InterruptedException e)
        {
            // Role of InterruptedException 
            // is to allow thread management.
            system.err.print(e);// Role of 
        }
    }
    public static void main(String[] args)
    {
        try
        {
            InterruptedExample ie = new InterruptedExample();
            new Thread(ie).start();
            // Here, we attempt to interrupt the 
            // newly created thread - may be ineffective.
            ie.interrupt;
        }
        catch(Exception e)
        {
            ;// The role of InterruptedException is in run method.
        }
    }       
}

What I have done here is a narrow focus on: what is the role of InterruptedException and my re-code may not be effective for Can you give clear explantion on that. Also, it may or may not interrupt, depending on things the code does not attempt to control. As EFH states, your originally posted code does not call interrupt() - which would mean no InterruptedException to catch.

For Object.notify() we have:

/**
* The awakened thread will not be able to proceed until the current thread relinquishes the
* lock on this object. The awakened thread will compete in the usual manner with any other
* threads that might be actively competing to synchronize on this object; for example, the
* awakened thread enjoys no reliable privilege or disadvantage in being the next thread to
* lock this object.
*/

Which does not say anything about InterruptedException, the re-write uses Thread.interrupt()