【多线程】Synchronized 原理

一. 基本特点

1. 开始时是乐观锁, 如果锁冲突频繁, 就转换为悲观锁.
2. 开始是轻量级锁实现, 如果锁被持有的时间较长, 就转换成重量级锁.
3. 实现轻量级锁的时候大概率用到的自旋锁策略.
4. 是一种不公平锁.
5. 是一种可重入锁.
6. 不是读写锁.

二. 加锁工作过程

JVM 将 synchronized 锁分为 无锁、偏向锁、轻量级锁、重量级锁状态。会根据情况，进行依次升级。

1. 偏向锁

第一个尝试加锁的线程, 优先进入偏向锁状态.

• 偏向锁不是真的 “加锁”, 只是给对象头中做一个 “偏向锁的标记”, 记录这个锁属于哪个线程.
• 如果后续没有其他线程来竞争该锁, 那么就不用进行其他同步操作了(避免了加锁解锁的开销)
• 如果后续有其他线程来竞争该锁(刚才已经在锁对象中记录了当前锁属于哪个线程了, 很容易识别当前申请锁的线程是不是之前记录的线程), 那就取消原来的偏向锁状态, 进入一般的轻量级锁状态.

偏向锁本质上相当于 “延迟加锁” . 能不加锁就不加锁, 尽量来避免不必要的加锁开销. 但是该做的标记还是得做的, 否则无法区分何时需要真正加锁.

2. 轻量级锁

随着其他线程进入竞争, 偏向锁状态被消除, 进入轻量级锁状态(自适应的自旋锁).
此处的轻量级锁就是通过 CAS 来实现.

• 通过 CAS 检查并更新一块内存 (比如 null => 该线程引用)
• 如果更新成功, 则认为加锁成功
• 如果更新失败, 则认为锁被占用, 继续自旋式的等待(并不放弃 CPU).

自旋操作是一直让 CPU 空转, 比较浪费 CPU 资源.
因此此处的自旋不会一直持续进行, 而是达到一定的时间/重试次数, 就不再自旋了.
也就是所谓的 “自适应”

3. 重量级锁

如果竞争进一步激烈, 自旋不能快速获取到锁状态, 就会膨胀为重量级锁
此处的重量级锁就是指用到内核提供的 mutex .

• 执行加锁操作, 先进入内核态.
• 在内核态判定当前锁是否已经被占用
• 如果该锁没有占用, 则加锁成功, 并切换回用户态.
• 如果该锁被占用, 则加锁失败. 此时线程进入锁的等待队列, 挂起. 等待被操作系统唤醒.
• 经历了一系列的沧海桑田, 这个锁被其他线程释放了, 操作系统也想起了这个挂起的线程, 于是唤醒这个线程, 尝试重新获取锁.

三. 锁粗化

一段逻辑中如果出现多次加锁解锁, 编译器 + JVM 会自动进行锁的粗化.

锁的粒度: 粗和细, 指加锁代码所涉及到的范围, 涉及的范围越大, 锁的粒度越粗, 涉及的范围越小,锁的粒度越细,
1

        Object locker = new Object();
        for (int i = 0; i < 100; i++) {
            synchronized (locker) {
                
            }
        }
1
2
3
4
5
6

        synchronized (locker) {
            for (int i = 0; i < 100; i++) {

            }
        }
1
2
3
4
5

第一段代码的锁的粒度就比较细, 第二段代码锁的粒度就比较粗

举个栗子:
领导给下属交代工作任务:
方式一:

• 打电话, 交代任务1, 挂电话.
• 打电话, 交代任务2, 挂电话.
• 打电话, 交代任务3, 挂电话.

方式二:

• 打电话, 交代任务1, 任务2, 任务3, 挂电话.

显然, 方式二是更高效的方案.

到底锁粒度粗好还是细好 ?

各有各的好:

• 粒度细, 其他为加锁的代码间就能并发执行, 多线程并发程度高, 但是加锁解锁的开销比较大
• 粒度粗, 加锁解锁的开销小, 但是并发程度低

编译器就会有一个优化, 自动判定, 如果某个地方锁粒度太细可能就会粗化, 避免频繁申请释放锁.

四. 锁消除

有些地方明明不用加锁却加上了锁, 编译器+JVM 判断锁是否可消除. 如果可以, 就直接消除.

注意: 锁消除和偏向锁不一样, 锁消除是不该加锁的地方但是加了, 偏向锁是需要加锁, 但是并没有真正的加锁,等.

有些应用程序的代码中, 用到了 synchronized, 但其实没有在多线程环境下. (例如 StringBuffer)

StringBuffer stringBuffer= new StringBuffer();
stringBuffer.append("a");
stringBuffer.append("b");
stringBuffer.append("c");
stringBuffer.append("d");
1
2
3
4
5

此时每个 append 的调用都会涉及加锁和解锁. 但如果只是在单线程中执行这个代码, 那么这些加锁解锁操作是没有必要的, 白白浪费了一些资源开销.

五. 相关面试题

1. 什么是偏向锁?
   偏向锁不是真的加锁, 而只是在锁的对象头中记录一个标记(记录该锁所属的线程). 如果没有其他线
   程参与竞争锁, 那么就不会真正执行加锁操作, 从而降低程序开销. 一旦真的涉及到其他的线程竞争, 再取消偏向锁状态, 进入轻量级锁状态.

2. synchronized 实现原理 是什么？
   上面所有的内容

好啦！ 以上就是对 Synchronized 原理的讲解，希望能帮到你 ！
评论区欢迎指正 !