IllegalMonitorStateException on wait call

Question

I am using multi-threading in java for my program  I have run thread successfully but when I am using Thread wait    it is throwing java lang IllegalMonitorStateException  How can I make a thread wait until it will be notified

User · Answer

Based on your comments it sounds like you are doing something like this:

Thread thread = new Thread(new Runnable(){
    public void run() { // do stuff }});

thread.start();
...
thread.wait();

There are three problems.

As others have said, obj.wait() can only be called if the current thread holds the primitive lock / mutex for obj. If the current thread does not hold the lock, you get the exception you are seeing.
The thread.wait() call does not do what you seem to be expecting it to do. Specifically, thread.wait() does not cause the nominated thread to wait. Rather it causes the current thread to wait until some other thread calls thread.notify() or thread.notifyAll().

There is actually no safe way to force a Thread instance to pause if it doesn't want to. (The nearest that Java has to this is the deprecated Thread.suspend() method, but that method is inherently unsafe, as is explained in the Javadoc.)

If you want the newly started Thread to pause, the best way to do it is to create a CountdownLatch instance and have the thread call await() on the latch to pause itself. The main thread would then call countDown() on the latch to let the paused thread continue.
Orthogonal to the previous points, using a Thread object as a lock / mutex may cause problems. For example, the javadoc for Thread::join says:

This implementation uses a loop of this.wait calls conditioned on this.isAlive. As a thread terminates the this.notifyAll method is invoked. It is recommended that applications not use wait, notify, or notifyAll on Thread instances.

User · Answer

Thread wait   call make sense inside a code that synchronizes on Thread class object  I don t think it s what you meant  You ask      How can I make a thread wait until it will be notified    You can make only your current thread wait  Any other thread can be only gently asked to wait  if it agree  If you want to wait for some condition  you need a lock object - Thread class object is a very bad choice - it is a singleton AFAIK so synchronizing on it  except for Thread static methods  is dangerous  Details for synchronization and waiting are already explained by Tom Hawtin  java lang IllegalMonitorStateException means you are trying to wait on object on which you are not synchronized - it s illegal to do so

User · Answer

You need to be in a synchronized block in order for Object wait   to work   Also  I recommend looking at the concurrency packages instead of the old school threading packages  They are safer and way easier to work with    Happy coding   EDIT  I assumed you meant Object wait   as your exception is what happens when you try to gain access without holding the objects lock

User · Answer

I know this thread is almost 2 years old but still need to close this since I also came to this Q A session with same issue     Please read this definition of illegalMonitorException again and again     IllegalMonitorException is thrown to indicate that a thread has attempted to wait on an object s monitor or to notify other threads waiting on an object s monitor without owning the specified monitor    This line again and again says  IllegalMonitorException comes when one of the 2 situation occurs      1  wait on an object s monitor without owning the specified monitor   2  notify other threads waiting on an object s monitor without owning the specified monitor   Some might have got their answers    who all doesn t  then please check 2 statements      synchronized  object   object wait    If both object are same    then no illegalMonitorException can come   Now again read the IllegalMonitorException definition and you wont forget it again

User · Answer

In order to deal with the IllegalMonitorStateException  you must verify that all invocations of the wait  notify and notifyAll methods are taking place only when the calling thread owns the appropriate monitor  The most simple solution is to enclose these calls inside synchronized blocks  The synchronization object that shall be invoked in the synchronized statement is the one whose monitor must be acquired   Here is the simple example for to understand the concept of monitor  public class SimpleMonitorState        public static void main String args    throws InterruptedException            SimpleMonitorState t   new SimpleMonitorState            SimpleRunnable m   new SimpleRunnable t           Thread t1   new Thread m           t1 start            t call                public void call   throws InterruptedException           synchronized  this                wait                System out println  Single by Threads                         class SimpleRunnable implements Runnable        SimpleMonitorState t       SimpleRunnable SimpleMonitorState t            this t   t              Override     public void run              try                  Sleep             Thread sleep 10000               synchronized  this t                    this t notify                            catch  InterruptedException e                e printStackTrace

User · Answer

I received a IllegalMonitorStateException while trying to wake up a thread in   from a different class   thread  In java 8 you can use the lock features of the new Concurrency API instead of synchronized functions   I was already storing objects for asynchronous websocket transactions in a WeakHashMap  The solution in my case was to also store a lock object in a ConcurrentHashMap for synchronous replies  Note the condition await  not  wait    To handle the multi threading I used a Executors newCachedThreadPool   to create a thread pool

User · Answer

wait is defined in Object  and not it Thread  The monitor on Thread is a little unpredictable   Although all Java objects have monitors  it is generally better to have a dedicated lock   private final Object lock   new Object      You can get slightly easier to read diagnostics  at a small memory cost  about 2K per process  by using a named class   private static final class Lock     private final Object lock   new Lock      In order to wait or notify notifyAll an object  you need to be holding the lock with the synchronized statement  Also  you will need a while loop to check for the wakeup condition  find a good text on threading to explain why    synchronized  lock        while   isWakeupNeeded              lock wait              To notify   synchronized  lock        makeWakeupNeeded        lock notifyAll        It is well worth getting to understand both Java language and java util concurrent locks locks  and java util concurrent atomic  when getting into multithreading  But use java util concurrent data structures whenever you can

User · Answer

Not sure if this will help somebody else out or not but this was the key part to fix my problem in user  Tom Hawtin - tacklin  s answer above   synchronized  lock        makeWakeupNeeded        lock notifyAll        Just the fact that the  lock  is passed as an argument in synchronized   and it is also used in  lock  notifyAll     Once I made it in those 2 places I got it working

User · Answer

Since you haven t posted code  we re kind of working in the dark   What are the details of the exception   Are you calling Thread wait   from within the thread  or outside it      I ask this because according to the javadoc for IllegalMonitorStateException  it is    Thrown to indicate that a thread has attempted to wait on an object s monitor or to notify other threads waiting on an object s monitor without owning the specified monitor     To clarify this answer  this call to wait on a thread also throws IllegalMonitorStateException  despite being called from within a synchronized block         private static final class Lock          private final Object lock   new Lock          Test     public void testRun             ThreadWorker worker   new ThreadWorker            System out println   Starting worker            worker start            System out println   Worker started - telling it to wait            try               synchronized  lock                    worker wait                            catch  InterruptedException e1                String msg    InterruptedException       e1 getLocalizedMessage                      System out println  msg               e1 printStackTrace                System out flush                      System out println   Worker done waiting  we re now waiting for it by joining            try               worker join              catch  InterruptedException ex

User · Answer

Those who are using Java 7 0 or below version can refer the code which I used here and it works   public class WaitTest        private final Lock lock   new ReentrantLock        private final Condition condition   lock newCondition         public void waitHere long waitTime            System out println  wait started               lock lock            try               condition await waitTime  TimeUnit SECONDS             catch  InterruptedException e                   TODO Auto-generated catch block             e printStackTrace                      lock unlock            System out println  wait ends here                  public static void main String   args              Your Code         new WaitTest   waitHere 10             Your Code

[java] IllegalMonitorStateException on wait() call

Examples related to java

Examples related to multithreading

Examples related to wait