public void A(){
     synchronized(Object.class){
        //业务  
     }
}
public void B(){
     synchronized(Object.class){
        //业务
     }
}

想问一下，AB两个方法，用的是都是Object.class作为锁，如果两个线程分别访问AB两个方法，A方法中的锁被占用，B方法synchronized中的业务会执行吗，两个Object是同一把锁吗

Object类对象只有一个，一个方法锁住了，另一个就要阻塞。
A方法锁住了，B方法肯定阻塞，等到A方法释放锁，B方法获取锁以后才能执行。
下面的代码是顺序执行的。

    public static void main(String[] args) {
        new Thread(No26_removeDuplicates::A).start();
        new Thread(No26_removeDuplicates::B).start();
    }

    public static void A() {
        synchronized (Object.class) {
            System.out.println("A start");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("A end");
        }
    }

    public static void B() {
        synchronized (Object.class) {
            System.out.println("B start");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("B end");
        }
    }

不会。锁定的是Object.class对象

Object.class 只有一个对象,所以第二个线程进不去,不过还是建立自己建立一个静态对象,这样就只会有一个

一个类中，synchronized 修饰实例方法 锁是 this

一个类中, synchronized 修饰静态方法 锁是 类名 .class

A方法占用锁，B方法肯定会阻塞住。因为这两个方法用的是同一把锁 Object.class

两个方法拿到的都是Object.class 锁， Object.class对象只存在一个，所以是同一把锁