1、synchronized加在不同位置的区别
-
普通同步方法,锁的是当前实例对象
-
对于同步代码块,锁的是Synchronized括号中的代码块
-
静态同步方法,锁的是当前Class对象
2、synchronized加在不同位置的实现方式
1、不用锁
首先用一个简单的代码来测试一下,有啥区别,首先是不加锁的正常代码,代码如下:
public class Test {
public static void main(String[] args) {
new Test().hello();
}
public void hello(){
System.out.println("hello world");
}
}
对其字节码文件用javap命令处理一下,编译并找到Test.class,使用 javap -v Test
命令
//这里我只截取了后面一部分主要的,前面的内容省略了。
public void hello();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #6 // String hello world
5: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 16: 0
line 17: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 this LTest;
2、锁代码块实现
然后将代码变成如下:
public class Test {
public static void main(String[] args) {
new Test().hello();
}
public void hello(){
//锁同步代码块
synchronized (this){
System.out.println("hello world");
}
}
}
重新编译后再次运行命令,得到如下结果。
//其余部分省略
//这是加了锁的字节码
public void hello();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=3, args_size=1
0: aload_0
1: dup
2: astore_1
3: monitorenter
4: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
7: ldc #6 // String hello world
9: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
12: aload_1
13: monitorexit
14: goto 22
17: astore_2
18: aload_1
19: monitorexit
20: aload_2
21: athrow
22: return
Exception table:
from to target type
4 14 17 any
17 20 17 any
LineNumberTable:
line 16: 0
line 17: 4
line 18: 12
line 19: 22
LocalVariableTable:
Start Length Slot Name Signature
0 23 0 this LTest;
StackMapTable: number_of_entries = 2
frame_type = 255 /* full_frame */
offset_delta = 17
locals = [ class Test, class java/lang/Object ]
stack = [ class java/lang/Throwable ]
frame_type = 250 /* chop */
offset_delta = 4
总结
对比发现,加了synchronized的多了很多东西,最明显的区别,多了monitorenter和monitorexit指令,也就是说,对于同步代码块,原理是在同步块的入口位置和退出位置分别插入monitorenter和monitorexit字节码指令,但是发现似乎多了一个monitorexit指令,这是为啥呢?这里是因为第一个monitorexit指令是同步代码块正常释放锁的一个标志,如果同步代码块中出现Exception或者Error,则会调用第二个monitorexit指令来保证释放锁,资料来源:
synchronized反汇编为什么有两个monitorexit
3、锁方法块实现
将代码再改一改,如下:
public class Test {
public static void main(String[] args) {
new Test().hello();
}
//锁方法
public synchronized void hello(){
System.out.println("hello world");
}
}
//其余部分省略
public synchronized void hello();
descriptor: ()V
flags: ACC_PUBLIC, ACC_SYNCHRONIZED
Code:
stack=2, locals=1, args_size=1
0: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #6 // String hello world
5: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 16: 0
line 17: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 this LTest;
总结
发现在方法上加锁的Code属性和不加锁的内容一模一样,然后仔细观察,发现flags属性比不加锁的多了一个ACC_SYNCHRONIZED标识,那么锁方法的实现并不是加monitorenter和monitorexit指令,而是在方法修饰标识那里加了一个ACC_SYNCHRONIZED标识,其实这也是符合常理的,因为它锁住的是整个方法,如果在Code里面加的话,那就每个线程就会同时进入这个方法,然后在判断是否取得锁,这样是不合理的,合理的应该是进入这个方法前去判断,线程是否取得锁,如果线程取得锁,那么就运行,反之就等待。
3、静态方法加锁
1、猜测
那么在静态方法加锁,不变的是,锁在方法上,只是这个方法是静态的,那么是不是和锁方法一样,在flags上添加ACC_SYNCHRONIZED标识,然后静态方法就是在flags上添加ACC_STATIC标识。
2、验证
修改代码如下:
public class Test {
public static void main(String[] args) {
new Test().hello();
}
public synchronized static void hello(){
System.out.println("hello world");
}
}
用javap反编译一下,得到如下结果:
//其余部分省略
public static synchronized void hello();
descriptor: ()V
flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
Code:
stack=2, locals=0, args_size=0
0: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #6 // String hello world
5: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 16: 0
line 17: 8
总结
和猜想的一样,只是在flags上加了一个ACC_STATIC标识,区别就变成静态方法和非静态方法的区别了。
总结
- 同步代码块即锁住对象是在同步代码块前后分别添加
monitorenter
和monitorexit
指令,只有当锁住的对象的对象头(后续会聊到)中的线程指针指向的那个线程才能执行同步代码块中的的代码,而其他线程则需要等待。 - 同步方法即在方法上进行加锁,和同步代码快不同,只是加了一个
ACC_SYNCHRONIZED
标识。