(Java) 线程安全使用 Object wait() 和 notify()

Question

I was looking for a way to make one thread wait/sleep until another thread signalled that something was ready. The waiting thread should wake up, process the data that was made available, then go back to sleep until the other thread signalled again.

The simplest method I could find was Object.wait() and Object.notify() , which behaved like a semaphore initialised to value 0. However, without the synchronized statements around notify/wait , Java always threw IllegalMonitorStateException when the thread was not the monitor owner. So I simply put them around the code like shown below.

THREAD 1: running infinite loop

public class Main {
    private Handler handler; // only one instance (singleton pattern)

    public void listen() {
        while (true) {
            try {
                synchronized (handler) { 
                    handler.wait();
                    int value = handler.getSize();
                    // do something
                }
            } catch (InterruptedException e) {
                // ...
            }
        }
    }
}

THREAD 2: Some other class calls removeItem

public class Handler {

    // SINGLETON PATTERN - ONLY ONE INSTANCE

    private ArrayList<Integer> sharedList;

    private Handler() {
        sharedList = new ArrayList<>();
    }

    public void addItem(Integer i) {
        synchronized (sharedList) {
            // add to list
        }
    }

    public void removeItem(int i) {
        synchronized (sharedList) {
            // remove item

            // notify that something is removed
            synchronized (this) {
                this.notify(); // this == handler
            }
        }
    }

    public int getSize() {
        synchronized (sharedList) {
            return sharedList.size();
        }
    }
}

It seems to work perfectly fine but not sure if there is a hidden bug. My question is: Is this safe? Does wait release the instance lock for handler/this so notify can acquire the lock?

Answer 1

Synchronized blocks are safe. The statement synchronized(obj) acquires the lock of the argument obj , so you can call wait and notify on it. They both require that the current thread holds the lock on the object.

You have to be careful about the double-locking you have in removeItem where you lock two objects. If you ever need this, you have to make sure that you always lock them in the same order, otherwise, you may create a deadlock.