每当遇到Java面试，“锁”是个必然会被提到的东西。那么，在面试中，谈“锁”都会谈论些什么呢，诸位看官又是否对“锁”有足够的了解？
本文旨在剖析锁的底层原理，以及锁的应用场景。
一、Synchronized
1、一道面试题
同一个对象在A、B两个线程中分别访问该对象的两个同步方法writer和reader，是否会产生互斥？
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 |
class {
int a = 0;
public synchronized void writer(){
sleep(10);
a++;
}
public synchronized void reader(){
int i = a;
}
public static void main(String[] args) {
Test test = new Test();
new Thread(() -> {
test.writer();
}).start();
sleep(1);
new Thread(() -> {
test.reader();
}).start();
}
}
|
答案：会。因为synchronized修饰的是方法，锁是对象锁,默认当前的对象作为锁的对象。只有当A释放锁之后，B才会获得对象的锁。
（1）如果是换成是不同对象呢？
不会互斥，因为锁的是对象，而不是方法。
（2）如果writer、reader方法加上static修饰，两个线程中，类直接调用两个方法呢？
会互斥，因为锁的是Class对象。
（3）如果writer方法用static修饰，reader方法不用呢？
不会互斥。因为一个是对象锁，一个是Class对象锁，锁的类型不同。
synchronized修饰位置与锁的关系：
- 同步方法 —— 对象锁，当前实例对象
- 静态同步方法 —— 类对象锁，当前对象的Class对象
- 同步方法块 —— 对象锁，synchonized括号里配置的对象
二、锁的底层实现
思考几个问题
- 对象锁、Class对象锁时如何实现的
- 为什么要这么设计，只设计一个对象锁或Class对象锁，有什么不好？
1、反编译
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 |
class {
static int a = 0;
public synchronized void writer() {
System.out.println("writer方法开始调用");
a++;
waitNs(20);
System.out.println("writer方法调用结束");
}
public static synchronized void reader() {
System.out.println("reader方法开始调用");
int i = a;
System.out.println("reader方法调用结束");
}
public void writer2() {
synchronized (this) {
a--;
}
}
}
|
使用javac和javap -verbose命令，反编译上述代码
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 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 |
...
{
static int a;
descriptor: I
flags: ACC_STATIC
public com.fonxian.entity.LockDemo();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 6: 0
//同步方法
public synchronized void writer();
descriptor: ()V
flags: ACC_PUBLIC, ACC_SYNCHRONIZED
Code:
stack=2, locals=1, args_size=1
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3 // String writer方法开始调用
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: getstatic #5 // Field a:I
11: iconst_1
12: iadd
13: putstatic #5 // Field a:I
16: bipush 20
18: invokestatic #6 // Method waitNs:(I)V
21: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
24: ldc #7 // String writer方法调用结束
26: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
29: return
LineNumberTable:
line 11: 0
line 12: 8
line 13: 16
line 14: 21
line 15: 29
//静态同步方法
public static synchronized void reader();
descriptor: ()V
flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
Code:
stack=2, locals=1, args_size=0
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #8 // String reader方法开始调用
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: getstatic #5 // Field a:I
11: istore_0
12: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
15: ldc #9 // String reader方法调用结束
17: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
20: return
LineNumberTable:
line 18: 0
line 19: 8
line 20: 12
line 21: 20
//同步代码块
public void writer2();
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 a:I
7: iconst_1
8: isub
9: putstatic #5 // Field a:I
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 25: 0
line 26: 4
line 27: 12
line 28: 22
StackMapTable: number_of_entries = 2
frame_type = 255 /* full_frame */
offset_delta = 17
locals = [ class com/fonxian/entity/LockDemo, class java/lang/Object ]
stack = [ class java/lang/Throwable ]
frame_type = 250 /* chop */
offset_delta = 4
static {};
descriptor: ()V
flags: ACC_STATIC
Code:
stack=1, locals=0, args_size=0
0: iconst_0
1: putstatic #5 // Field a:I
4: return
LineNumberTable:
line 8: 0
}
SourceFile: "LockDemo.java"
|
同步代码块：使用monitorenter和monitorexit指令实现，通过监听器对象去获得锁和释放锁。
同步方法、静态同步方法：使用修饰符ACC_SYNCHRONIZED实现。
三、锁的形式
JDK1.6之前，synchronized只有传统锁机制。
JDK1.6引入两种新的锁类型：偏向锁和轻量级锁。引入的目的是解决，没有多线程竞争或基本没有竞争的情况下，使用传统锁带来的性能问题。
锁的四种状态：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态。锁可以升级，不能降级。
1、对象头
要了解锁的机制，首先要了解对象头。
Java对象头中的Mark Word默认存储对象的HashCode、分代年龄和锁标记位。
Java对象头的存储结构如下:
| 锁状态 | 25bit | 4bit | 1bit是否是偏向锁 | 2bit锁标志位 |
|---|---|---|---|---|
| 无锁状态 | 对象的hashCode | 对象的分代年龄 | 0 | 01 |
Mark Word的状态变化:
| 锁状态 | 30bit | 2bit |
|---|---|---|
| 轻量级锁 | 指向栈中锁记录的指针 | 锁标志位00 |
| 重量级锁 | 指向互斥量的指针 | 锁标志位10 |
| 锁状态 | 23bit | 3bit | 3bit | 1bit | 2bit |
|---|---|---|---|---|---|
| 偏向锁 | 线程ID | Epoch | 对象分代年龄 | 1 | 01 |
2、偏向锁
因大多数情况，锁不存在多线程竞争，且总由同一个线程多次获得。为使获得锁的代价更低而引入。
3、轻量级锁
参考文档
原文地址：https://www.cnblogs.com/petewell/p/11614914.html
时间： 2024-10-10 09:37:11