Synchronized作用在静态和非静态方法上的区别

synchronized关键字的用法主要有以下几种：

1. 作用在非静态方法上

   非静态方法是只能提供类的实例进行调用，所以实际上就是对调用方法的对象加锁，俗称对象锁

2. 作用在静态方法上

   静态方法是可以通过类名直接调用，所以实际上就是对调用方法的类加锁，俗称类锁

3. 作用在代码块

   根据传入的是类对象或类实例判断加锁方式

场景分析

// 静态同步方法
class SyncStaticClazz {

  	// 静态实例同步方法
    public static synchronized void method1() {
        System.out.println("static---method1--" + Thread.currentThread());
        try {Thread.sleep(2000);} catch (InterruptedException e) {}
    }

  	// 静态实例同步方法
    public static synchronized void method2() {
        System.out.println("static---method2--" + Thread.currentThread());
        try {Thread.sleep(2000);} catch (InterruptedException e) {}
    }

  	// 非静态实例同步方法
    public synchronized void method3() {
        System.out.println("static---method3--" + Thread.currentThread());
        try {Thread.sleep(2000);} catch (InterruptedException e) {}
    }

}

// 非静态同步方法
class SyncNormalClazz {

  	// 非静态实例同步方法
    public synchronized void method1() {
        System.out.println("normal---method1--" + Thread.currentThread());
        try {Thread.sleep(2000);} catch (InterruptedException e) {}
    }

  	// 类级别的同步代码块
    public void method2() {
        synchronized (SyncNormalClazz.class) {
            System.out.println("normal---method2--" + Thread.currentThread());
            try {Thread.sleep(2000);} catch (InterruptedException e) {}
        }
    }

  	// 类级别的同步代码块
    public void method3() {
        synchronized (SyncNormalClazz.class) {
            System.out.println("normal---method3--" + Thread.currentThread());
            try {Thread.sleep(2000);} catch (InterruptedException e) {}
        }
    }

  	// 类实例级别的同步代码块
    public void method4() {
        synchronized (this) {
            System.out.println("normal---method4--" + Thread.currentThread());
            try {Thread.sleep(2000);} catch (InterruptedException e) {}
        }
    }

}

• 场景1

  • 描述：使用类对象在不同线程中访问不同的静态同步方法

    new Thread(() -> {
        SyncStaticClazz.method1();
    }, "ssc1").start();
    
    new Thread(() -> {
        SyncStaticClazz.method2();
    }, "ssc2").start();
    

  • 结果：互斥

  • 解析：静态同步方法的加锁范围是整个类，所以无论是使用对象或类去访问静态同步方法，锁都会加到类对象上。就好比是房子的大门，房子内不论有多少房间，只要有一个人打开大门进入到房子里，其他人就只能等他出来之后再进去，而已经进去的人拥有所有房间的使用权。

• 场景2

  • 描述：在不同线程中用不同的类实例访问相同静态方法

    new Thread(() -> {
        SyncStaticClazz c = new SyncStaticClazz();
        c.method1();
    }, "ssc1").start();
    
    new Thread(() -> {
        SyncStaticClazz c = new SyncStaticClazz();
        c.method1();
    }, "ssc2").start();
    

  • 结果：互斥

  • 解析：和场景1相同，静态方法虽然可以被类实例访问，但锁依然是类锁

• 场景3

  • 描述：同一个对象在不同线程中访问不同的非静态同步方法

    SyncNormalClazz snc = new SyncNormalClazz();
    new Thread(() -> {
        snc.method1();
    }, "snc1").start();
    
    new Thread(() -> {
        snc.method2();
    }, "snc2").start();
    

  • 结果：互斥

  • 解析：非静态方法上加的是对象锁，当对象调用一个非静态的同步方法时，其他的非静态同步方法需要等待被执行。

• 场景4

  • 描述：不同对象在不同线程中访问同一个非静态方法

    new Thread(() -> {
        SyncNormalClazz snc = new SyncNormalClazz();
        snc.method1();
    }, "snc1").start();
    
    new Thread(() -> {
        SyncNormalClazz snc = new SyncNormalClazz();
        snc.method1();
    }, "snc2").start();
    

  • 结果：不互斥

  • 解析：因为通过不同的对象调用的是非静态方法，虽然调用的是同一个方法，但是非静态方法加的锁是对象锁，针对的是对象并不是方法，所以可以并发执行，不会互斥。如果像场景1中的比喻的话，就是两个对象是两套房子，户型相同而已。

• 场景5

  • 描述：不同对象在不同线程中访问同一个非静态非同步方法，方法内通过synchronized锁定代码块，且锁定对象为类对象

    new Thread(() -> {
        SyncNormalClazz snc = new SyncNormalClazz();
        snc.method2();
    }, "snc3").start();
    
    new Thread(() -> {
        SyncNormalClazz snc = new SyncNormalClazz();
        snc.method2();
    }, "snc4").start();
    

  • 结果：互斥

  • 解析：因为方法method2()内的synchronized锁的是SyncNormalClazz.class，也就是锁定的是类对象，所以与场景2相同

• 场景6

  • 描述：同一个对象在不同线程中访问不同的非静态非同步方法，方法内通过synchronized锁定代码块，且锁定对象为类对象

    SyncNormalClazz snc = new SyncNormalClazz();
    new Thread(() -> {
        snc.method2();
    }, "snc2").start();
    
    new Thread(() -> {
        snc.method3();
    }, "snc3").start();
    

  • 结果：互斥

  • 解析：因为方法method2()内的synchronized锁的是SyncNormalClazz.class，也就是锁定的是类对象，所以与场景2相同

• 场景7

  • 描述：同一个对象在不同线程中访问不同方法，一个调用静态方法，一个调用非静态方法

    SyncStaticClazz ssc = new SyncStaticClazz();
    new Thread(() -> {
        ssc.method2();
    }, "ssc2").start();
    
    new Thread(() -> {
        ssc.method3();
    }, "ssc3").start();
    

  • 结果：不互斥

  • 解析：虽然是同一个对象调用，但是两个方法的锁类型不同，静态方法是类锁，非静态方法是对象锁，所以不会互斥

• 场景8

  • 描述：同一个对象在不同线程中访问不同synchronized代码块方法，一个调用类对象同步，一个调用类实例同步

    SyncNormalClazz ssc = new SyncNormalClazz();
    new Thread(() -> {
        ssc.method3();
    }, "snc3").start();
    
    new Thread(() -> {
        ssc.method4();
    }, "snc4").start();
    

  • 结果：不互斥

  • 解析：与场景8相同

总结

• 对象锁仅锁当前对象，不同对象之间不会互斥
• 静态方法上的锁是类锁，非静态方法上的锁是对象锁
• 所有静态同步方法互斥，无论是通过类调用还是对象调用
• 静态方法上加synchronized与在非静态方法内加synchronized(Xxx.class)效果一致，都是类锁