Is synchronized needed here

Answer 1

A given thread is required to own a lock on a object to be able to call wait(long) on it. This is achieved by using a synchronized block on the said object.

See J2SE specification on using wait.

Acquiring a lock/monitor in java can be done in various ways:

• In a synchronized (non-static) method, the thread owns a monitor on the object referenced by this.
• In a static synchronized method, the thread owns a monitor on the Class<?> descriptor for the class that defines the said method.
• In a synchronized(x) block, the thread owns a monitor on x.

That lock will be released if:

• You get outside of the synchronized code block (be it a method, static method, or explicit block).
• You have called wait() or one of its variations (and you'll re-acquire it just before the method returns).

Both these two lists may omit specific cases but should cover at least a large portion of the typical use cases.

Answer 2

Can you please post SessionThread code? You cannot wait if you don't own the lock, so you need synchronized (_sessionThread) to do _sessionThread.wait(30000); Not sure what's with _sessionThread._stopStartSession = true;

Answer 3

There's a very simple reason that you need synchronized to call wait

The synchronized makes sure that nobody is calling notify or notifyAll at the same time you're calling wait

For example: Thread 1

synchronized( obj )
{
    triggerActionOnThread2();
    obj.wait();
}

Thread 2 (triggered by triggerActionOnThread2)

    ...
    synchronized( obj )
    {
        obj.notify();
    }

If you don't have the synchronized blocks, then the notify might happen before (or during) the wait, and then the wait misses the notify, and you can hang Thread 1.

Imagine the above blocks of code without the synchronized blocks, and imagine if Thread 2 is executed all the way through the notify before the wait gets called.

BTW, I ask this very question on interviews for Java engineers when the job will involve multithreaded programming.

Answer 4

If the boolean is the only shared state between the threads, declaring the boolean transient will guarantee that changes to it are seen between the threads as would a synchronization block around access to the boolean.