Java多线程 细说 synchronized

首先分享之前的所有文章 , 欢迎点赞收藏转发三连下次一定 >>>> 😜😜😜

文章合集 : 🎁 juejin.cn/post/694164…

Github : 👉 github.com/black-ant

CASE 备份 : 👉 gitee.com/antblack/ca…

1.1 synchronized 简述

synchronized 被称为重量级锁 , 但是 1.6 版本后得到了优化 , 相对轻量了很多, 它可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块 .

主要操作对象是方法或者代码块中存在的共享数据, 同时可保证一个线程的变化(主要是共享数据的变化)被其他线程所看
synchronized 的核心原理为 Java 对象头以及 Monitor
- JVM基于进入和退出Monitor对象来实现方法同步和代码块同步

1.2 Java 对象头和 Monitor

对象头结构

java复制代码// 原理 -->  
1 Java 对象头 和 Monitor
|-> 对象头 ：
    |-> Mark Word（标记字段）、Klass Pointer（类型指针）
    |-> Klass Pointer : 类元数据指针，决定是何数据
    |-> Mark Word : 自身运行时数据 （hashcode,锁状态，偏向，标志位等）
|-> Monitor : 
    |-> 互斥 ：一个 Monitor 锁在同一时刻只能被一个线程占用
    
    
// 关系 -->  
- Monitor 是一种对象类型 , 任何Java 对象都可以是 Monitor 对象
- 当Java 对象被 synchronized 修饰时 , 就可以当成 Monitor 对象进行处理
    

// Mark Word 和 Class Metadata Address 组成结构
--------------------------------------------------------------------------------------------------    
虚拟机位数	头对象结构	            说明
|---------|-----------------------|---------------------------------------------------------------|  
32/64bit	Mark Word	            存储对象的hashCode、锁信息或分代年龄或GC标志等信息
32/64bit	Class Metadata Address	类型指针指向对象的类元数据，JVM通过这个指针确定该对象是哪个类的实例。
--------------------------------------------------------------------------------------------------

32 位虚拟机 Mark Word >>>>

64 位虚拟机 Mark Word >>>>

数据结构

java复制代码// Monitor 的实现方式 @ https://blog.csdn.net/javazejian/article/details/70768369
ObjectMonitor中有两个队列以及一个区域
     _WaitSet 和 _EntryList，用来保存ObjectWaiter对象列表( 每个等待锁的线程都会被封装成ObjectWaiter对象) 
     _owner (指向持有ObjectMonitor对象的线程) 区域

1 当多个线程同时访问一段同步代码时，首先会进入 _EntryList 集合, 此时开始尝试获取monitor
2 当线程获取到对象的monitor 后进入 _Owner 区域 ,并把 monitor中的owner变量 设置为当前线程同时monitor中的计数器count加1
3 若线程调用 wait() 方法，将释放当前持有的monitor，owner变量恢复为null，count自减1，同时该线程进入 WaitSet集合中等待被唤醒。
4 若当前线程执行完毕也将 释放monitor(锁) 并复位变量的值，以便 其他线程进入获取monitor(锁)

Monitor 指令

monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit是插入到方法结束处和异常处，JVM要保证每个monitorenter必须有对应的monitorexit与之匹配

查看汇编情况 :

java复制代码// Step 1 : 准备简单的Demo
public class SynchronizedService {
    public void method() {
        synchronized (this) {
            System.out.println("synchronized 代码块");
        }
    }
}

// Step 2 : 查看汇编码
javap -c -s -v -l SynchronizedService.class


// Step 3 : 注意其中 3 和 13 以及 19 
public void method();
    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     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         7: ldc           #3                  // String synchronized 代码块
         9: invokevirtual #4                  // 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

处理逻辑详情 :

java复制代码// synchronized 源码分析 @ https://blog.csdn.net/javazejian/article/details/70768369  
// 具体的流程可以参考上面博客的具体分析, 此处仅总结 , 大佬们肝真好


// synchronized 代码块底层逻辑 ( monitorenter 和 monitorexit )
> synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，
其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置

Start : 当执行monitorenter指令时，当前线程将试图获取 objectref(即对象锁) 所对应的 monitor 的持有权
Thread-1  : objectref.monitor = 0 --> 获取monitor --> 设置计数器值为 1 
Thread-2  : 发现objectref.monitor = 0 --> 阻塞等待 --> Thread-1 执行 monitorexit ,
            计数器归 0 --> Thread-2 正常流程获取获取monitor

注意点 : 
编译器将会确保无论方法通过何种方式完成，方法中调用过的每条 monitorenter 指令都有执行其对应 monitorexit 指令 , 
方法异常时通过异常处理器处理异常结束

synchronized 方法底层逻辑 (ACC_SYNCHRONIZED标识)

方法级的同步是隐式，即无需通过字节码指令来控制的，它实现在方法调用和返回操作之中。
JVM可以从方法常量池中的方法表结构(method_info Structure) 中的 ACC_SYNCHRONIZED 访问标志区分一个方法是否同步方法。

方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置
|- 如果设置了，执行线程将先持有monitor（虚拟机规范中用的是管程一词），然后再执行方法，最后再方法完成(无论是正常完成还是非正常完成)时释放monitor。
在方法执行期间，执行线程持有了monitor，其他任何线程都无法再获得同一个monitor

异常处理 : 如果一个同步方法执行期间抛出了异常，并且在方法内部无法处理此异常，那这个同步方法所持有的monitor将在异常抛到同步方法之外时自动释放

synchronized 内存级原理

1 2	java复制代码// 最后生成的汇编语言 lock cmpxchg %r15, 0x16(%r10) 和 lock cmpxchg %r10, (%r11)

synchronized的底层操作含义是先对对象头的锁标志位用lock cmpxchg的方式设置成”锁住”状态
释放锁时，在用lock cmpxchg的方式修改对象头的锁标志位为”释放”状态，写操作都立刻写回主内存。
JVM会进一步对synchronized时CAS失败的那些线程进行阻塞操作，这部分的逻辑没有体现在lock cmpxchg指令上，我猜想是通过某种信号量来实现的。
lock cmpxchg 指令前者保证了可见性和防止重排序，后者保证了操作的原子性。

1.3 synchronized 用法

java复制代码// 加锁方式 ，当前实例 ，当前class , 自定义object
> synchronized(this)
> synchronized(object)
> synchronized(class) 或者静态代码块

synchronized关键字最主要的三种使用方式：

修饰实例方法，作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁
修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁。
- 也就是给当前类加锁，会作用于类的所有对象实例，因为静态成员不属于任何一个实例对象，是类成员（ static 表明这是该类的一个静态资源，不管new了多少个对象，只有一份，所以对该类的所有对象都加了锁）。
- 所以如果一个线程A调用一个实例对象的非静态 synchronized 方法，而线程B需要调用这个实例对象所属类的静态 synchronized 方法，是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的锁，而访问非静态 synchronized 方法占用的锁是当前实例对象锁。
修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。
- 和 synchronized 方法一样，synchronized(this)代码块也是锁定当前对象的。
- synchronized 关键字加到 static 静态方法和 synchronized(class)代码块上都是是给 Class 类上锁。

这里再提一下：synchronized关键字加到非 static 静态方法上是给对象实例上锁。

另外需要注意的是 尽量不要使用 synchronized(String a), 部分字符串常量会缓冲到常量池里面, 不过可以试试 new String(“a”)

1.4 synchronized 其他知识点

解释 : synchronized 提供了一种独占式的加锁方式，其添加和释放锁的方式由JVM实现
阻塞 : 当 synchronized 尝试获取锁的时候，获取不到锁，将会一直阻塞

谈谈 synchronized和ReenTrantLock 的区别

两者都是可重入锁
synchronized 依赖于 JVM 而 ReenTrantLock 依赖于 API
ReenTrantLock 比 synchronized 增加了一些高级功能
- 等待可中断；可实现公平锁；可实现选择性通知（锁可以绑定多个条件）

synchronized 与等待唤醒机制 (notify/notifyAll和wait)
等待唤醒机制需要处于synchronized代码块或者synchronized方法中 , 调用这几个方法前必须拿到当前对象的监视器monitor对象

synchronized 与线程中断
线程的中断操作对于正在等待获取的锁对象的synchronized方法或者代码块并不起作用

1.5 多线程中的锁概念

1.5.1 锁按照等级分类

锁可以按照以下等级进行升级 : 偏向锁 -> 轻量级锁 -> 重量级锁 , 锁的升级是单向的

偏向锁
- 减少同一线程获取锁的代价 (在大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得)
- 如果一个线程获得了锁，那么锁就进入偏向模式，此时Mark Word 的结构也变为偏向锁结构，当这个线程再次请求锁时，无需再做任何同步操作，即获取锁的过程
- 偏向锁失败后，并不会立即膨胀为重量级锁，而是先升级为轻量级锁
轻量级锁
- 对绝大部分的锁，在整个同步周期内都不存在竞争
- 轻量级锁所适应的场景是线程交替执行同步块的场合
- 如果存在同一时间访问同一锁的场合，就会导致轻量级锁膨胀为重量级锁
自旋锁
- 假设等待后当前的线程可以获得锁，因此虚拟机会让当前想要获取锁的线程做几个空循环
- 在经过若干次循环后，如果得到锁，就顺利进入临界区。如果还不能获得锁，那就会将线程在操作系统层面挂起
- 可以减少了线程上下文切换，但是增加了CPU消耗
重量级锁

1.5.2 锁的操作

锁清除 :

Java虚拟机在 JIT编译时 (可以简单理解为当某段代码即将第一次被执行时进行编译，又称即时编译)，通过对运行上下文的扫描，去除不可能存在共享资源竞争的锁，通过这种方式消除没有必要的锁，可以节省毫无意义的请求锁时间

Java 常见的锁

synchronized 关键字 , 重量锁
ReentrantLock 重入锁
ReadWriteLock 读写锁

1.5.3 其他锁概念

内部锁 :

synchronized : 锁对象的引用 , 锁保护的代码块
每个Java 对象都可以隐式地扮演一个用于同步的锁的角色 ,这些内置的锁被称为内部锁或监视器锁 .

公平锁/非公平锁

公平锁是指多线程按照申请锁的顺序来获取锁，非公平锁指多个线程获取锁的顺序不是按照申请锁的顺序，有可能造成优先级反转或者饥饿现象，
非公平锁的优点在于吞吐量比公平锁大，ReentrantLock默认非公平锁，可通过构造函数选择公平锁，Synchronized是非公平锁。

可重入锁
可重入锁指在一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁，ReentrantLock与Synchronized都是可重入的。

独享锁/共享锁
独享锁是指一个锁只能一个线程独有，共享锁指一个锁可被多个线程共享，对于ReadWriteLock，读锁是共享锁，写锁是独享所。

互斥锁/读写锁
独享锁/共享锁是一种广义的说法，互斥锁/读写锁是其具体实现。

乐观锁/悲观锁

乐观锁与悲观锁是看待同步的角度不同，乐观锁认为对于同一个数据的修改操作，是不会有竞争的，会尝试更新，如果失败，不断重试。
悲观锁与此相反，直接获取锁，之后再操作，最后释放锁。

分段锁

分段锁是一种设计思想，通过将一个整体分割成小块，在每个小块上加锁，提高并发。

1.6 锁的转换过程

java复制代码对象头的变化可以看下图 , 说的很清楚了  @ https://www.cnblogs.com/jhxxb/p/10983788.html

// 之前知道 , 锁的状态改变是单向的 , 由 偏向锁 -> 轻量级锁 -> 重量级锁 ,我们分别捋一下

// 偏向锁 -> 偏向锁, 即重偏向操作
1 对象先偏向于某个线程， 执行完同步代码后 , 进入安全点时，若需要重偏向，会把类对象中 epoch 值增加
2 退出安全点后 , 当有线程需要尝试获取偏向锁时， 直接检查类实例对象中存储的 epoch 值与类对象中存储的 epoch 值是否相等， 如果不相等， 则说明该对象的偏向锁已经无效了， 可以尝试对此对象重新进行偏向操作。

// 偏向锁 -> 轻量级锁 
1 当发现对象已被锁定 ,且 ThreadID 不是自己 , 转为 偏向锁 , 在该线程的栈帧中建立 Lock Record 空间

1.7 为什么锁会转换

java复制代码// 这要从机制说起 , 每一种锁都有各自的特点

> 偏向锁
- 优点 : 无 CAS ,消耗少 , 性能高 ,  可重入
- 缺点 : 锁竞争时撤销锁消耗高
- 场景 : 同一个线程执行同步代码

> 轻量级锁
- 优点 : 竞争的线程不会阻塞
- 缺点 : 轻量级锁未获取锁时会通过自旋获取 , 消耗资源
- 场景 : 线程交替执行同步块或者同步方法，追求响应时间，锁占用时间很短

> 重量级锁
- 优点 : 线程竞争不使用自旋 , 只会唤醒和等待
- 缺点 : 造成线程阻塞 , 锁的改变也消耗资源
- 场景 : 追求吞吐量，锁占用时间较长

// 针对不同的需求 , 选择合适的锁 , 达到业务目的

锁状态pg.jpg

1.8 Synchoized 源码

java复制代码
synchronized 是一个修饰符 , 我们需要从 C 的角度去看 


Step 1 : 下载 OpenJDK 代码 https://blog.csdn.net/leisure_life/article/details/108367675
Step 2 : 根据代码索引 .c 文件



// TODO

1.9 Synchoized 用法

java复制代码public void operation(Integer check) {

    /**
     * 校验无锁情况
     */
    public void functionShow(Integer check) {
        logger.info("------> check is {} <-------", check);
        if (check == 0) {
            showNum = 100;
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else if (check == 1) {
            showNum = 200;
        }
        logger.info("------> check is Over {} :{}", check, showNum);
    }

    /**
     * 同步方法 , 校验 synchronized 方法
     */
    synchronized public void functionShowSynchronized(Integer check) {
        logger.info("------> check is {} <-------", check);
        if (check == 0) {
            showNum = 100;
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else if (check == 1) {
            showNum = 200;
        }
        logger.info("------> check is Over synchronized {} :{}", check, showNum);
    }

    /**
     * 校验 synchronized 代码块
     */
    public void statementShowSynchronized(Integer check) {
        logger.info("------> check is {} <-------", check);
        synchronized (this) {
            if (check == 0) {
                showNum = 100;
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else if (check == 1) {
                showNum = 200;
            }
        }
        logger.info("------> check is Over synchronized {} :{}", check, showNum);
    }
    
    // 校验 代码块以 Class 为对象
    public void classShowSynchronized(Integer check) {
        logger.info("check is {} <-------", check);
        synchronized (CommonTO.class) {
            if (check == 0) {
                showNum = 100;
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else if (check == 1) {
                showNum = 200;
            }
        }
        logger.info("check is Over synchronized {} :{}", check, showNum);
    }
    
    // 同步代码块 Object
    public void objectShowSynchronized(Integer check) {
        logger.info("check is {} <-------", check);
        synchronized (lock) {
            if (check == 0) {
                showNum = 100;
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else if (check == 1) {
                showNum = 200;
            }
        }
        logger.info("check is Over synchronized {} :{}", check, showNum);
    }
    
    // 同步代码块 Object
    public void objectStringShowSynchronized(Integer check) {
        logger.info("check is {} <-------", check);
        synchronized (lock2) {
            if (check == 0) {
                showNum = 100;
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else if (check == 1) {
                showNum = 200;
            }
        }
        logger.info("check is Over synchronized {} :{}", check, showNum);
    }

总结

逐步更新 , 逐步完善

更新日记

V20210727 : 补充细节点 , 优化内容
V20210813 : 补充深入细节 , Java 并发编程的艺术
V20210814 : 补充汇编细节

参考文档

《深入浅出 Java 多线程》

《Java并发编程的艺术》

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有