java synchronized锁不同class的区别是什么

下面两段代码有什么区别，有大神给答案吗，好像锁不同对象没什么区别啊

code 1

synchronized (A.class) {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

code 2

synchronized (B.class) {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

---

好多人说没有区别，这样吧，直接上代码和结果吧

public class Test {

    static Runnable lock = new Runnable() {
        @Override
        public void run() {
            synchronized (A.class) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };

    static Runnable syncA = new Runnable() {
        @Override
        public void run() {
            A.syncShowTime();
        }
    };

    static Runnable syncB = new Runnable() {
        @Override
        public void run() {
            B.syncShowTime();
        }
    };

    static Runnable lockA = new Runnable() {
        @Override
        public void run() {
            A.lockShowTime();
        }
    };

    static Runnable lockB = new Runnable() {
        @Override
        public void run() {
            B.lockShowTime();
        }
    };

    static Runnable instA = new Runnable() {
        @Override
        public void run() {
            A a = new A();
            a.instShowTime();
        }
    };

    static Runnable instB = new Runnable() {
        @Override
        public void run() {
            B b = new B();
            b.instShowTime();
        }
    };

    public static void main(String args[]) {
        try {
            new Thread(lock).start();
            Thread.sleep(1000);
            System.out.println("S:" + (int) (System.currentTimeMillis() / 1000L));
            new Thread(syncA).start();
            new Thread(syncB).start();
            new Thread(lockA).start();
            new Thread(lockB).start();
            new Thread(instA).start();
            new Thread(instB).start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class A {
    static synchronized void syncShowTime() {
        System.out.println("A sync:" + (int) (System.currentTimeMillis() / 1000L));
    }

    static void lockShowTime() {
        synchronized (A.class) {
            System.out.println("A lock:" + (int) (System.currentTimeMillis() / 1000L));
        }
    }

    void instShowTime() {
        synchronized (A.class) {
            System.out.println("A inst:" + (int) (System.currentTimeMillis() / 1000L));
        }
    }
}

class B {
    static synchronized void syncShowTime() {
        System.out.println("B sync:" + (int) (System.currentTimeMillis() / 1000L));
    }

    static void lockShowTime() {
        synchronized (B.class) {
            System.out.println("B lock:" + (int) (System.currentTimeMillis() / 1000L));
        }
    }

    void instShowTime() {
        synchronized (B.class) {
            System.out.println("B inst:" + (int) (System.currentTimeMillis() / 1000L));
        }
    }
}

S:1469596337
B sync:1469596337
B lock:1469596337
B inst:1469596337
A inst:1469596341
A lock:1469596341
A sync:1469596341

---

没有区别，但是请注意，当使用class做为锁的时候由于jvm中每个具体的类只有一个class对象，所以很可能在别处也用了同样的class做为了锁，此时很有可能不注意会造成死锁，实际开发中为了防止误造成死锁的风险，所以可能都是在本类中直接synchronized或者直接用ReentrantLock或者直接new个object当锁

---

我想题主的意思是synchronized后面的括号里面放A.class和B.class有什么区别，两段代码并不是共存的，楼上的哥们好像理解错题主意思了。如果楼主是这个问题的话，那基本没啥区别。如果这两段代码分别在同一个类的不同方法中，那两个线程可以同时访问同一个对象的这两个方法，并没有什么影响，因为是不同的锁。so，看题主你的问题是什么了

---

你这问题就好像声明一个int a和声明一个int b有什么区别一样

int a;
int b;