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

Java 评论

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

  1. 作用在非静态方法上

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

  2. 作用在静态方法上

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

  3. 作用在代码块

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

场景分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
// 静态同步方法
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

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

      1
      2
      3
      4
      5
      6
      7
      new Thread(() -> {
          SyncStaticClazz.method1();
      }, "ssc1").start();

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

    • 结果：互斥

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

  • 场景2

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

      1
      2
      3
      4
      5
      6
      7
      8
      9
      new Thread(() -> {
          SyncStaticClazz c = new SyncStaticClazz();
          c.method1();
      }, "ssc1").start();

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

    • 结果：互斥

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

  • 场景3

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

      1
      2
      3
      4
      5
      6
      7
      8
      SyncNormalClazz snc = new SyncNormalClazz();
      new Thread(() -> {
          snc.method1();
      }, "snc1").start();

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

    • 结果：互斥

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

  • 场景4

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

      1
      2
      3
      4
      5
      6
      7
      8
      9
      new Thread(() -> {
          SyncNormalClazz snc = new SyncNormalClazz();
          snc.method1();
      }, "snc1").start();

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

    • 结果：不互斥

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

  • 场景5

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

      1
      2
      3
      4
      5
      6
      7
      8
      9
      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锁定代码块，且锁定对象为类对象

      1
      2
      3
      4
      5
      6
      7
      8
      SyncNormalClazz snc = new SyncNormalClazz();
      new Thread(() -> {
          snc.method2();
      }, "snc2").start();

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

    • 结果：互斥

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

  • 场景7

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

      1
      2
      3
      4
      5
      6
      7
      8
      SyncStaticClazz ssc = new SyncStaticClazz();
      new Thread(() -> {
          ssc.method2();
      }, "ssc2").start();

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

    • 结果：不互斥

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

  • 场景8

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

      1
      2
      3
      4
      5
      6
      7
      8
      SyncNormalClazz ssc = new SyncNormalClazz();
      new Thread(() -> {
          ssc.method3();
      }, "snc3").start();

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

    • 结果：不互斥

    • 解析：与场景8相同

总结

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

串一串浪人

断舍离