同步块不锁定对象引用

class Demo
{
    void demo()
    {
        System.out.println("Inside demo of "+Thread.currentThread().getName());
        try
        {
            Thread.sleep(1000000);
        }
        catch(InterruptedException exc)
        {
            System.out.println(Thread.currentThread().getName()+" interrupted");
        }
    }
}

class MyThread1 implements Runnable
{
    Thread thread;
    Demo d;

    MyThread1(String name, Demo ob)
    {
        d = ob;
        thread = new Thread(this, name);
        thread.start();
    }

    @Override
    public void run()
    {
        System.out.println(thread.getName()+" starting");

        synchronized(d)
        {
            d.demo();
        }

        System.out.println(thread.getName()+" ending");
    }
}

class MyThread2 implements Runnable
{
    Thread thread;
    Demo d;

    MyThread2(String name, Demo ob)
    {
        d = ob;
        thread = new Thread(this, name);
        thread.start();
    }

    @Override
    public void run()
    { 
       System.out.println(thread.getName()+" starting");

       d.demo();

       System.out.println(thread.getName()+" ending");
    }
}

class TimePass
{
    public static void main(String args[])
    {
        Demo d = new Demo();

        MyThread1 mt1 = new MyThread1("Thread 1", d);
        MyThread2 mt2 = new MyThread2("Thread 2", d);
    }
}

输出是

线程 1 开始

线程 1 的内部演示

线程2开始

Thread 2 的内部演示

Due to Thread.sleep(1000000)，执行尚未结束。

我已经通过了同一个类的实例Demo到类的两个构造函数MyThread1 and MyThread2.

Demo d = new Demo();
MyThread1 mt1 = new MyThread1("Thread 1", d);
MyThread2 mt2 = new MyThread2("Thread 2", d);

致电给d.demo in MyThread1是在一个synchronized block.
致电给d.demo in MyThread2 is not in a synchronized block.

所以，当MyThread1正在执行，由于synchronized块，监视器d应被锁定，导致拒绝访问d.demo() by the MyThread2.

但这并没有发生。

预期输出是

Thread 1 starting
Inside demo of Thread1
Thread 2 starting

（输出是之前Thread.sleep(1000000)已完成。）

所以，我的基本问题是：How MyThread2.d.demo()即使执行成功MyThread1.d.demo()尚未完成synchronized block?

因此，当 MyThread1 执行时，由于synchronized块，监视器d应被锁定，导致拒绝访问d.demo()通过 MyThread2。

只有当 MyThread2 也有一个时才会发生这种情况synchronized堵塞。当一个线程在一个对象上同步时，如果其他线程也尝试在同一对象上同步，则它们将被阻塞。如果它们不同步，它们就不会同步。没有什么可以阻止不同步的线程访问对象。

同步是一个合作社机制。它仅在所有线程一起工作时才有效。