深入并发-Synchronized

野性酷女 2022-11-03 05:47 146阅读 0赞

synchronized的使用  
在多线程并发编程中synchronized一直是元老级角色，很多人都会称呼它为重量级锁。但是，随着Java SE 1.6对 synchronized进行了各种优化之后，有些情况下它就并不那么重了，Java SE 1.6中为了减少获得锁和释放锁带来的 性能消耗而引入的偏向锁和轻量级锁，以及锁的存储结构和升级过程。通过 synchronized关键字来修饰在inc的方法上,看看执行结果。（可以自己尝试将synchronizrd去掉，看看结果得到的是不是1000）

public class Demo\{  
    private static int count=0;  
    public static void inc()\{  
        synchronized (Demo.class) \{  
            try \{  
                Thread.sleep(1);  
            \} catch (InterruptedException e) \{  
                e.printStackTrace();  
            \}  
            count++;   
        \}  
    \}  
    public static void main(String\[\] args) throws InterruptedException \{  
        for(int i=0;i<1000;i++)\{  
            new Thread(()->Demo.inc()).start();  
        \}  
        Thread.sleep(3000);  
        System.out.println("运行结果"+count);   
    \}  
\}  
synchronized的三种应用方式  
synchronized有三种方式来加锁，分别是

修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁  
静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁  
修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。  
synchronized括号后面的对象  
synchronized扩号后面的对象是一把锁，在java中任意一个对象都可以成为锁。简单来说，我们把object比喻是一 个key，拥有这个key的线程才能执行这个方法，拿到这个key以后在执行方法过程中，这个key是随身携带的并且只有一把。如果后续的线程想访问当前方法，因为没有key所以不能访问只能在门口等着，等之前的线程把key放回去。所以，synchronized锁定的对象必须是同一个，如果是不同对象，就意味着是不同的房间的钥匙，对于访问者来说是没有任何影响的

synchronized的字节码指令  
通过javap -v 来查看对应代码的字节码指令，对于同步块的实现使用了monitorenter和monitorexit指令，他们隐式的执行了Lock和UnLock操作，用于提供原子性保证。 monitorenter指令插入到同步代码块开始的位置、monitorexit指令插入到同步代码块结束位置，jvm需要保证每个monitorenter都有一个monitorexit对应。

这两个指令，本质上都是对一个对象的监视器(monitor)进行获取，这个过程是排他的，也就是说同一时刻只能有 一个线程获取到由synchronized所保护对象的监视器。

线程执行到monitorenter指令时，会尝试获取对象所对应的monitor所有权，也就是尝试获取对象的锁；而执行 monitorexit 就是释放monitor的所有权。

对象在内存中的布局  
在 Hotspot 虚拟机中，对象在内存中的存储布局，可以分为三个区域:对象头(Header)、实例数据(Instance Data)、对齐填充(Padding)。其中对象头包含对象标记和类元信息两部分，Java对象头是实现 synchronized的锁对象的基础。一般而言，synchronized使用的锁对象是存储在Java对象头里。它是轻量级锁和偏向锁的关键。

Mawrk Word  
Mark Word（对象标记）用于存储对象自身的运行时数据，如哈希码(HashCode)、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等等。Java对象头一般占有两个机器码(在32位虚拟机中，1个机器码等于4字节， 也就是32bit)

Monitor  
什么是Monitor?

1.Monitor是一种用来实现同步的工具

2.与每个java对象相关联，所有的 Java 对象是天生携带 monitor

3.Monitor是实现Sychronized(内置锁)的基础

对象的监视器（monitor）由ObjectMonitor对象实现（C++），其跟同步相关的数据结构如下：

ObjectMonitor() \{  
    \_count        = 0; //用来记录该对象被线程获取锁的次数  
    \_waiters      = 0;  
    \_recursions   = 0; //锁的重入次数  
    \_owner        = NULL; //指向持有ObjectMonitor对象的线程   
    \_WaitSet      = NULL; //处于wait状态的线程，会被加入到\_WaitSet  
    \_WaitSetLock  = 0 ;  
    \_EntryList    = NULL ; //处于等待锁block状态的线程，会被加入到该列表  
\}  
synchronized的锁升级和获取过程  
首先来了解相关锁的概念：

自旋锁(CAS)：让不满足条件的线程等待一会看能不能获得锁，通过占用处理器的时间来避免线程切换带来的开销。自旋等待的时间或次数是有一个限度的，如果自旋超过了定义的时间仍然没有获取到锁，则该线程应该被挂起。在 JDK1.6 之后，引入了自适应自旋锁，自适应意味着自旋的次数不是固定不变的，而是根据前一次在同一个锁上自旋的时间以及锁的拥有者的状态来决定。如果在同一个锁对象上，自旋等待刚刚成功获得过锁，并且持有锁的线程正在运行中，那么虚拟机就会认为这次自旋也是很有可能再次成功，进而它将允许自旋等待持续相对更长的时间。如果对于某个锁，自旋很少成功获得过，那在以后尝试获取这个锁时将可能省略掉自旋过程，直接阻塞线程，避免浪费处理器资源。

偏向锁：大多数情况下，锁总是由同一个线程多次获得。当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，偏向锁是一个可重入的锁。如果锁对象头的Mark Word里存储着指向当前线程的偏向锁，无需重新进行CAS操作来加锁和解锁。当有其他线程尝试竞争偏向锁时，持有偏向锁的线程（不处于活动状态）才会释放锁。偏向锁无法使用自旋锁优化，因为一旦有其他线程申请锁，就破坏了偏向锁的假定进而升级为轻量级锁。

轻量级锁：减少无实际竞争情况下，使用重量级锁产生的性能消耗。JVM会现在当前线程的栈桢中创建用于存储锁记录的空间 LockRecord，将对象头中的 Mark Word 复制到 LockRecord 中并将 LockRecord 中的 Owner 指针指向锁对象。然后线程会尝试使用CAS将对象头中的Mark Word替换为指向锁记录的指针，成功则当前线程获取到锁，失败则表示其他线程竞争锁当前线程则尝试使用自旋的方式获取锁。自旋获取锁失败则锁膨胀升级为重量级锁。

重量级锁：通过对象内部的监视器(monitor)实现，其中monitor的本质是依赖于底层操作系统的Mutex Lock实 现，操作系统实现线程之间的切换需要从用户态到内核态的切换，切换成本非常高。线程竞争不使用自旋，不会消耗CPU。但是线程会进入阻塞等待被其他线程被唤醒，响应时间缓慢。

从网上找来的一张图，完美诠释了synchronized锁的升级过程。

Synchronized 结合 Java Object 对象中的 wait,notify,notifyAll  
前面我们在讲 synchronized 的时候，发现被阻塞的线程什 么时候被唤醒，取决于获得锁的线程什么时候执行完同步代码块并且释放锁。那怎么做到显示控制呢？我们就需要借助一个信号机制：在 Object 对象中，提供了wait/notify/notifyall，可以用于控制线程的状态。

wait/notify/notifyall 基本概念  
wait：表示持有对象锁的线程 A 准备释放对象锁权限，释放 cpu 资源并进入等待状态。

notify：表示持有对象锁的线程 A 准备释放对象锁权限，通知 jvm 唤醒某个竞争该对象锁的线程 X。 线程 A synchronized 代码执行结束并且释放了锁之后，线程 X 直接获得对象锁权限，其他竞争线程继续等待(即使线程 X 同步完毕，释放对象锁，其他竞争线程仍然等待，直至有新的 notify ,notifyAll 被调用)。

notifyAll：notifyall 和 notify 的区别在于，notifyAll 会唤醒所有竞争同一个对象锁的所有线程，当已经获得锁的线程 A 释放锁之后，所有被唤醒的线程都有可能获得对象锁权限。

需要注意的是：三个方法都必须在 synchronized 同步关键字所限定的作用域中调用，否则会报错 java.lang.IllegalMonitorStateException 。意思是因为没有同步，所以线程对对象锁的状态是不确定的，不能调用这些方法。另外，通过同步机制来确保线程从 wait 方法返回时能够感知到 notify 线程对变量做出的修改。

常见面试题：wait/notify/notifyall为什么需要在synchronized里面？

1.wait 方法的语义有两个，一个是释放当前的对象锁、另一个是使得当前线程进入阻塞队列， 而这些操作都和监视器是相关的，所以 wait 必须要获得一个监视器锁。

2.对于 notify 来说也是一样，它是唤醒一个线程，既然要去唤醒，首先得知道它在哪里?所以就必须要找到这个对象获取到这个对象的锁，然后到这个对象的等待队列中去唤醒一个线程。

3.每个对象可能有多个线程调用wait方法，所以需要有一个等待队列存储这些阻塞线程。这个等待队列应该与这个对象绑定，在调用wait和notify方法时也会存在线程安全问题所以需要一个锁来保证线程安全。

wait/notify 的基本原理

————————————————  
版权声明：本文为CSDN博主「岁月安然」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/baidu\_38083619/article/details/82527461