Question

The following code blocks in synchronized sync() method before calling plain() method. Why is this so, shouldn’t the intrinsic lock block call to synchronized methods only – for example this behavior would have been fine if plain() was synchronized as well.

As the monitor concept that java uses is applicable to synchronized methods/blocks only – it by definition should not affect execution of non synchronized code. Is this always the case or is this behavior JVM implementation specific.

public class Main {

    public static void main(final String[] args) {
        final Main main = new Main();
        new Thread(new Runnable() {
            @Override
            public void run() {
                main.sync();
            }
        }).run();
        main.plain();
    }

    public synchronized void sync() {
        try {
            System.out.println("sleeping...");
            Thread.sleep(2000);
            System.out.println("out...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void plain() {
        System.out.println("plain...");
    }
}

Output:

sleeping...
out...
plain...

Answer 1

You should call start() rather than run() on the new Thread. Calling run() will execute the runnable’s run method in the current thread, rather than starting a new thread to run it.