synchronized关键字的用法主要有以下几种:
-
作用在非静态方法上
非静态方法是只能提供类的实例进行调用,所以实际上就是对调用方法的对象加锁,俗称对象锁
-
作用在静态方法上
静态方法是可以通过类名直接调用,所以实际上就是对调用方法的类加锁,俗称类锁
-
作用在代码块
根据传入的是类对象或类实例判断加锁方式
场景分析
// 静态同步方法
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)效果一致,都是类锁