Java 两个不同线程上的同步块，具有相同的对象引用，仍然同时执行

您没有将同一实例用于锁

此

是

可运行的

实例，

t1

是

线程

实例

我更喜欢声明

private static Object LOCK=new Object（），这是内存中最小的实例，很容易知道它的用途

根据评论编辑（斯蒂芬·弗兰克）

这与
synchronized（MyClass.class）
有一些相似之处，但由于任何人都可以访问
MyClass.class
的此实例，因此任何人都可以使用此锁，因此任何人都可以创建死锁，使用一个特定的实例可以帮助您，如果需要，可以让您共享。
您没有将同一实例用于锁

此
是
可运行的
实例，
t1
是
线程
实例

我更喜欢声明
private static Object LOCK=new Object（），这是内存中最小的实例，很容易知道它的用途

根据评论编辑（斯蒂芬·弗兰克）

这与
synchronized（MyClass.class）
有一些相似之处，但由于任何人都可以访问
MyClass.class
的此实例，因此任何人都可以使用此锁，因此任何人都可以创建死锁，使用一个特定的实例可以帮助您，如果您愿意，请与他人分享。
注意：
此
是
可运行的
实例，而不是第7行的
线程。注意：
此
是
可运行的
实例，而不是第7行的
线程
。由于
已同步的
块位于静态方法内，您还可以使用类对象
SynchronizedTest.class
作为锁。另请参见此处：@SteffenFrank确实如此，但我更喜欢使用此解决方案，因为它更易于管理，我不能限制
MyClass.class
访问，但我可以为我的
锁
执行此操作。这增加了它的安全性。与非静态方式的
this
vs
private Object LOCK=new Object（）
相同。由于
synchronized
块位于静态方法内，因此也可以使用类对象
SynchronizedTest.class
进行锁定。另请参见此处：@SteffenFrank确实如此，但我更喜欢使用此解决方案，因为它更易于管理，我不能限制
MyClass.class
访问，但我可以为我的
锁
执行此操作。这增加了它的安全性。与此
vs
private Object LOCK=new Object（）
以非静态方式相同。
public class SynchronizedTest
{
  public static void main(String argv[])
  { 
     Thread t1 = new Thread(new Runnable(){public void run()
     {
        synchronized (this)    //line 7
        {
            for(int i=0; i<100; i++)
                System.out.println("thread A "+i);
        }

    }});
    t1.start();
    synchronized(t1)       // line 15
    {
        for(int i=0; i<100; i++)
            System.out.println("thread B "+i);
    }
  }     
} 

   thread B 62
   thread B 63 
   thread B 64
   thread A 0
   thread A 1
   thread A 2
   thread B 65
   thread A 3