Java线程同步概念静态函数[重复]

Question

最近我的朋友在一次采访中被问到这个问题。

问题：我们有 A 类，有 2 个方法 X1 和 X2。 X1 是静态同步的，X2 是同步的。

class A {
    public static synchronized X1() {
    }
    public synchronized X2() {
    }
}

现在我们知道静态同步获得了 CLASS 上的锁，而同步获得了调用对象上的锁。

面试官问“锁定CLASS是什么意思？”。锁定总是在对象上完成。那么在静态同步的情况下实际会发生什么。它锁定了 WHICH OBJECT？

有人能帮我澄清一下这个概念吗，因为这里有点混乱。

Answer 1

根据Oracle concurrency tutorial：

你可能想知道当一个静态同步方法是 调用，因为静态方法与类相关联，而不是 目的。在这种情况下，线程为 与类关联的类对象。从而访问类的静态 字段由不同于任何锁的锁控制 类的实例。

Answer 2

正如SO answer 准确指出的那样

there is no link between synchronized static methods and sync'ed non static methods in 
this context

为了证明这一点。

public class SimpleClassTest {

静态同步方式

public static synchronized void X1() {
        System.out.println("Before X1 Exec.. From"+Thread.currentThread().getName());
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("After X1 Exec.. From"+Thread.currentThread().getName());
    }

非静态同步方法

public synchronized void X2() {
        System.out.println(" X2 Exec.. From"+Thread.currentThread().getName());
    }

第一种方法只是休眠一段时间然后醒来。 第二种方法同步但不是静态的。

现在尝试创建两个线程并同时调用这个方法（大约）

public static void main(String args[]){
        final SimpleClassTest instance = new SimpleClassTest();

静态的第一个线程

    Thread t1 = new Thread(new Runnable() {

        @Override
        public void run() {
            SimpleClassTest.X1();
        }
    },"Thread1");

非静态的第二个线程

    Thread t2 = new Thread(new Runnable() {

        @Override
        public void run() {
            instance.X2();
        }
    },"Thread2");

现在启动两个线程

    t1.start();
    t2.start();

结果

Before X1 Exec.. FromThread1
 X2 Exec.. FromThread2
After X1 Exec.. FromThread1

从结果来看，两个线程运行时没有相互锁定。因为如果第一个线程锁定了第二个线程锁定的同一个对象，那么线程 2 将等待第一个线程完成。

因此，我们确信两者都是并行运行的。

第一个线程锁定了 SimpleClasstest.class，因为它是与实例无关的静态方法。

第二个线程锁定实例，因为它是非静态的。

希望可以解决