java - 方法同步以不同的方式处理不同的对象初始化

Question

根据我的代码，我有三个类:

显示:

class Display
{
    synchronized public void wish(String name)
    {
        for(int i = 0; i < 3; i++)
        {
            System.out.print("Good Morning: ");
            try
            {
                Thread.sleep(1000);
            }
            catch (InterruptedException ie)
            {
            }
            System.out.println(name);
        }
    }
}

我的线程:

class MyThread extends Thread
{
    String name;
    Display d;


    MyThread(Display d, String name)
    {
        this.name = name;
        this.d = d;
    }

    @Override
    public void run()
    {
        d.wish(name); 
    }
}

演示:

class SynchronizedDemo 
{
    public static void main(String[] args) 
    {
        Display d = new Display();
        MyThread mt1 = new MyThread(d, "foo");
        MyThread mt2 = new MyThread(d, "bar");

        mt1.start();
        mt2.start();
    }
}

当我运行 Demo 类时它工作正常并且我得到以下输出:

Good Morning: bar
Good Morning: bar
Good Morning: bar
Good Morning: foo
Good Morning: foo
Good Morning: foo

Output completed (6 sec consumed) - Normal Termination

到这里我完全明白sleep()方法不会释放对象锁，所以一旦一个线程进入wish()方法，它完成了它的工作，那么只有另一个线程可能有机会。

但是如果我按如下方式更改我的 MyThread 类:

class MyThread extends Thread
{
    String name;
    Display d;


    MyThread(Display d, String name)
    {
        this.name = name;
        this.d = d;
    }

    Display d1 = new Display();

    @Override
    public void run()
    {
        d1.wish(name); 
    }
}

现在，唯一的变化是我使用了在 MyThread 类中初始化的 Display 类对象。但是出乎我意料的是:

Good Morning: Good Morning: foo
Good Morning: bar
Good Morning: bar
Good Morning: foo
Good Morning: bar
foo

Output completed (3 sec consumed) - Normal Termination

这里可以通过输出清楚地理解，只要一个线程进入 hibernate 状态，其他线程就有机会执行 wish()。

Answer 1

在第二个示例中，d1 是内联初始化的 MyThread 类的成员(这只是在构造函数中初始化它的语法糖)。 MyThread 的每个实例都有自己的 Display 实例，因此同步是没有意义的 - 它们是两个不同的对象，在两个不同的监视器上同步。