Java多线程 : 细说 synchronized

梦里梦外; 2022-08-31 13:25 207阅读 0赞

--------------------

## theme: awesome-green   highlight: a11y-dark ##

> 总文档 :[文章目录][Link 1]  
>   
> Github : https://github.com/black-ant

### 1.1 synchronized 简述 ###

synchronized 是一种重量级锁 , 可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块 .

*  主要操作对象是方法或者代码块中存在的共享数据, 同时可保证一个线程的变化(主要是共享数据的变化)被其他线程所看
 *  synchronized 的核心原理为 Java 对象头 以及 Monitor

### 1.2 Java 对象头 和 Monitor ###

// 原理
    1 Java 对象头 和 Monitor
    	|-> 对象头 ：Mark Word（标记字段）、Klass Pointer（类型指针）
    		|-> Klass Pointer : 类元数据指针，决定是何数据
    		|-> Mark Word : 自身运行时数据 （hashcode,锁状态，偏向，标志位等）
    	|-> Monitor : 
    		|-> 互斥 ：一个 Monitor 锁在同一时刻只能被一个线程占用
    
    // Mark Word 和 Class Metadata Address 组成结构
    --------------------------------------------------------------------------------------------------    
    虚拟机位数	头对象结构	            说明
    |---------|-----------------------|---------------------------------------------------------------|  
    32/64bit	Mark Word	            存储对象的hashCode、锁信息或分代年龄或GC标志等信息
    32/64bit	Class Metadata Address	类型指针指向对象的类元数据，JVM通过这个指针确定该对象是哪个类的实例。
    --------------------------------------------------------------------------------------------------  
    
    // 32位JVM的Mark Word默认存储结构
    --------------------------------------------------------------------------------------------------           
      锁状态	       25bit	            4bit	         1bit是否是偏向锁	      2bit 锁标志位
    |--------|--------------------|--------------------|----------------------|----------------------|  
     无锁状态	  对象HashCode	       对象分代年龄	            0	                    01
    --------------------------------------------------------------------------------------------------

![d00ad16e70554f99bc65d34b6b8d7aa3.png][]

// 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(锁)

![e51e794b9150d3e42bc55c8d6500f19c.png][]

// 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 访问标志区分一个方法是否同步方法。

1.  方法调用时，调用指令将会 检查方法的 ACC\_SYNCHRONIZED 访问标志是否被设置  
    |- 如果设置了，执行线程将先持有monitor（虚拟机规范中用的是管程一词）， 然后再执行方法，最后再方法完成(无论是正常完成还是非正常完成)时释放monitor。
2.  在方法执行期间，执行线程持有了monitor，其他任何线程都无法再获得同一个monitor。  
    Error : 如果一个同步方法执行期间抛 出了异常，并且在方法内部无法处理此异常，那这个同步方法所持有的monitor将在异常抛到同步方法之外时自动释放

> synchronized 内存级原理

// 最后生成的汇编语言 
    lock cmpxchg %r15, 0x16(%r10)  和 lock cmpxchg %r10, (%r11)

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

### 1.3 synchronized 用法 ###

// 加锁方式 ，当前实例 ，当前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 其他知识点 ###

// 解释
    1 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 锁的转换过程 ###

对象头的变化可以看下图 , 说的很清楚了  @ https://www.cnblogs.com/jhxxb/p/10983788.html
    
    // 之前知道 , 锁的状态改变是单向的 , 由 偏向锁 -> 轻量级锁 -> 重量级锁 ,我们分别捋一下
    
    // 偏向锁 -> 偏向锁, 即重偏向操作
    1 对象先偏向于某个线程， 执行完同步代码后 , 进入安全点时，若需要重偏向，会把类对象中 epoch 值增加
    2 退出安全点后 , 当有线程需要尝试获取偏向锁时， 直接检查类实例对象中存储的 epoch 值与类对象中存储的 epoch 值是否相等， 如果不相等， 则说明该对象的偏向锁已经无效了， 可以尝试对此对象重新进行偏向操作。
    
    // 偏向锁 -> 轻量级锁 
    1 当发现对象已被锁定 ,且 ThreadID 不是自己 , 转为 偏向锁 , 在该线程的栈帧中建立 Lock Record 空间

![lock\_satus.jpg][lock_satus.jpg]

### 1.7 为什么锁会转换 ###

// 这要从机制说起 , 每一种锁都有各自的特点
    
    > 偏向锁
    - 优点 : 无 CAS ,消耗少 , 性能高 ,  可重入
    - 缺点 : 锁竞争时撤销锁消耗高
    - 场景 : 同一个线程执行同步代码
    
    > 轻量级锁
    - 优点 : 竞争的线程不会阻塞
    - 缺点 : 轻量级锁未获取锁时会通过自旋获取 , 消耗资源
    - 场景 : 线程交替执行同步块或者同步方法，追求响应时间，锁占用时间很短
    
    > 重量级锁
    - 优点 : 线程竞争不使用自旋 , 只会唤醒和等待
    - 缺点 : 造成线程阻塞 , 锁的改变也消耗资源
    - 场景 : 追求吞吐量，锁占用时间较长

![锁状态pg.jpg][pg.jpg]

### 1.8 Synchoized 源码 ###

synchronized 是一个修饰符 , 我们需要从 C 的角度去看 
    
    
    Step 1 : 下载 OpenJDK 代码 https://blog.csdn.net/leisure_life/article/details/108367675
    Step 2 : 根据代码索引 .c 文件
    
    
    
    // TODO

### 1.9 Synchoized 用法 ###

public void operation(Integer check) { 
    
            // 案例一 : 校验无锁情况
    // functionShow(check);
    
            // 案例二 : 校验 synchronized 方法
            functionShowSynchronized(check);
    
            // 案例三 : 校验 synchronized 代码块
    // statementShowSynchronized(check);
    
            // 案例四 : 校验 代码块以 Class 为对象
    // classShowSynchronized(check);
    
            // 案例五 : 同步代码块 Object
    // objectShowSynchronized(check);
    
            // 案例五 : 同步代码块 Object
    // objectStringShowSynchronized(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 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);
        }
    
        /** * */
        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);
        }
    
        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);
        }
    
        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);
        }
    
        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);
        }

[Link 1]: https://juejin.cn/post/6941642435189538824
[d00ad16e70554f99bc65d34b6b8d7aa3.png]: /images/20220829/2c5913dd262848d89deb5d4655b66ce3.png
[e51e794b9150d3e42bc55c8d6500f19c.png]: /images/20220829/5ce27762dfae4d59ae5e66c67438b53e.png
[lock_satus.jpg]: /images/20220829/5aedb7e3733841faa13a62235565389d.png
[pg.jpg]: /images/20220829/98c7978a68f54530a3820e305bc34e93.png