baton.notifyAll给出java.lang.IllegalMonitorStateException尽管同步（蝙蝠）

Question

I am new to multi threading and sorry for small question. I could not find what is wrong in below code. I am getting

0-Exception in thread "Thread-0" java.lang.IllegalMonitorStateException

What I'm trying to achieve

I am trying to create an array of worker threads, each of which will print the value that is set for that particular Thread object. I want the threads to wait for their turn to come and then they will execute the code and update value of baton (I suspect I am doing this wrong) before notifying the other threads, so that the next thread in the cycle will then repeat the process.

Here is my code. Thanks!

package test;

public class NThread
{
  public static Integer baton;

  public static void main(String[] args) throws InterruptedException
  {
    baton = 0;
    TestUtil.N = 2;
    runThread();
  }

  protected static void runThread() throws InterruptedException
  {
    int i;
    ThreadB b[] = new ThreadB[TestUtil.N];
    for (i = 0; i < TestUtil.N; i++)
    {
      b[i] = new ThreadB();
      b[i].val = i;
      b[i].start();
    }
  }
}

class ThreadB extends Thread
{
  public int val;

  @Override
  public void run()
  {
    synchronized (NThread.baton)
    {
      while (true)
      {
        if (NThread.baton != val)
        {
          try
          {
            NThread.baton.wait();
          }
          catch (InterruptedException e)
          {
            e.printStackTrace();
          }
        }
        else
        {
          TestUtil.printNum(val);
          NThread.baton = (NThread.baton+1) % TestUtil.N;
          NThread.baton.notifyAll();
        }
      }
    }
  }
}

Answer 1

You do synchronized (NThread.baton) , but then inside that synchronized section you change the baton object reference using NThread.baton = (NThread.baton+1) % TestUtil.N; . As you now have a new object reference in baton you are no longer locking on it, so when you next call baton.notifyAll() it is on an object you haven't synchronized on - hence your IllegalMonitorStateException .

To fix this you need to split out your synchronization object (and make it immutable using final - which is always a good rule anyway) from your trigger (your baton ). ie have a single static final Object monitor = new Object(); which you synchronize, wait and notify on, and keep baton for your numeric trigger.

A lightly updated sample is:

class ThreadB implements Runnable {
    public final int val;
    public ThreadB(int val) { this.val = val; }

    @Override public void run() {
        try {
            //  synchronize outside the loop so we don't constantly lock/unlock
            synchronized (NThread.monitor) {
                while (true) { // spin until interrupted
                    while (NThread.baton != val) // handle spurious wake-ups
                        NThread.monitor.wait();
                    //  print, increment and notify
                    TestUtil.printNum(val);
                    NThread.baton = (NThread.baton + 1) % TestUtil.N;
                    NThread.monitor.notifyAll();
                }
            }
        } catch (InterruptedException e) {
            // if interrupted then we exit
        }
    }
}

run using:

public class NThread {
    public static int baton;
    public static final Object monitor = new Object();

    public static void main(String[] args) throws InterruptedException {
        baton = 0;
        TestUtil.N = 2;
        runThread();
    }

    protected static void runThread() throws InterruptedException {
        int i;
        Thread b[] = new Thread[TestUtil.N];
        for (i = 0; i < b.length; i++) { // loop limit is on the array length - its clearer like that
            b[i] = new Thread(new ThreadB(i));
            b[i].start();
        }
        TimeUnit.SECONDS.sleep(1);
        for (i = 0; i < b.length; i++) b[i].interrupt();
        for (i = 0; i < b.length; i++) b[i].join();
        System.out.println("All done");
    }
}

This would usually undergo a lot more refactoring, such as injecting the common monitor, baton and number of participants into the Runnable's constructor to prevent making those fields public (usually using some kind of custom class to contain them all). I didn't go that far so you could see the link to your original code.

As a separate footnote, it is also better practice not to override Thread and run , but instead to split out your actions from the threading objects, and so make ThreadB implement Runnable , which you then provide to the constructor of a Thread .

Answer 2

You have to understand that synchronized does not apply a lock to the field you are storing a value in, but on the object that is stored in that field.

To execute wait or notifyAll you are required to have monitor lock on the object you are executing this for. I think you noticed that problem, because you are using the boxing class Integer instead of a int for the field. You did this because synchronized did complain that it can't lock on a value type. During the incrementation a new boxing object is created. And this new object is not any longer covered by the synchronized block.

In your case I think the best solution is to use a utility object that you can use for locking. Any simple instance of Object will do.