synchronized块没有锁定对象引用

Question

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开始

线程2的内部演示

由于Thread.sleep(1000000),执行尚未结束.

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

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

对d.demoin 的调用MyThread1是一个synchronized块.
要在通话d.demo中MyThread2是没有的synchronized块.

所以,当MyThread1被执行时,由于synchronized块,的监视器d应锁定,导致拒绝访问,以d.demo()由所述MyThread2.

但这不会发生.

预期的产出是

Thread 1 starting
Inside demo of Thread1
Thread 2 starting

(输出在之前Thread.sleep(1000000)完成.)

所以,我的基本问题是:即使尚未完成阻止,如何MyThread2.d.demo()成功执行？MyThread1.d.demo()synchronized

Answer 1

因此,当MyThread1正在执行时,由于该synchronized块,d应该锁定监视器,导致d.demo()MyThread2 拒绝访问.

只有当MyThread2也有一个synchronized块时,才会发生这种情况.当一个线程在一个对象上同步时,如果其他线程也尝试在同一个对象上进行同步,则会阻止其他线程.如果他们不同步,他们就不会.没有什么可以阻止从不同步的线程访问对象.

同步是一种合作机制.它仅在所有线程协同工作时有效.