Question

I’m coming from .NET world, and unfortunately looking Java source with .NET‘s eyes.

Following code is from Android Apps (though not Android specific at all):

    private class Worker implements Runnable {
        private final Object mLock = new Object();
        private Looper mLooper;

        Worker(String name) {
            Thread t = new Thread(null, this, name);
            t.start();
            synchronized (mLock) {
                while (mLooper == null) {
                    try {
                        mLock.wait();
                    } catch (InterruptedException ex) {
                    }
                }
            }
        }

        public Looper getLooper() {
            return mLooper;
        }

        public void run() {
            synchronized (mLock) {
                Looper.prepare();
                mLooper = Looper.myLooper();
                mLock.notifyAll();
            }
            Looper.loop();
        }

        public void quit() {
            mLooper.quit();
        }
    }

I’m not precisely clear with how synchronized works.
First I thought that synchronized is locking mLock object, but then if after t.start() constructor thread enters sync block first, it would block it at mLock.wait(), and implicitly block thread “t” by blocking it from entering synchronized block.

This is obviously wrong, because my phone rings as supposed 🙂

Next thought is that synchronize synchronizes “code block” (in which case, there two synchronized block are independent => threads can enter two different sync block at same time without restriction), and that fitted perfectly…

… until my colleague told me that mLock.wait() releases lock on mLock and enables other thread to enter critical section on mLock in same time.

I’m not sure if I was clear enough, so will gladly answer any further questions on this.

Answer 1

Check out the javadoc on Object.wait(). It’s “magic” in that it drops the monitor that was acquired when entering the synchronized {} block. That allows another thread to acquire the monitor and call Object.notify().

When another thread calls notify() to wake the waiting thread from its wait() call, the waiting thread must re-acquire the monitor and will block until it can — the monitor is only dropped for the duration of the wait() call. And the notifying thread completes its synchronized block before the newly-awoken waiting thread can proceed. Everything is sequenced predictably.