Java并发编程——synchronized详解

最新推荐文章于 2024-06-20 20:20:21 发布

21cppSry_

最新推荐文章于 2024-06-20 20:20:21 发布

阅读量619

点赞数 17

分类专栏： Java并发编程文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_66510521/article/details/136442478

版权

Java并发编程专栏收录该内容

3 篇文章 0 订阅

订阅专栏

synchronized 用法

注意点：

一把锁只能同时被一个线程获取，没有获得锁的线程只能等待
每个实例都对应自己的一把锁（this）,不同实例之间互不影响，例外：锁对象是*.class以及synchronized修饰的是static方法的时候，所有对象共用同一把锁
synchronized修饰的方法，无论方法正常执行完毕还是抛出异常，都会释放锁

对象锁

包括方法锁(默认锁对象为this,当前实例对象)和同步代码块锁(自己指定锁对象)

类锁

指synchronize修饰静态的方法或指定锁对象为Class对象

Monitor

Monitor 被翻译成管程或监视器

管程（Monitor）是一种用于实现并发控制的机制。它提供了一种线程间同步的方式，以确保多个线程能够按照特定的规则进行协调和互动

管程的主要目的是解决多线程环境下的互斥访问和协调通信问题。

每个 Java 对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量级）之后，该对象头的 Mark Word 中就被设置指向 Monitor 对象的指针

Monitor 结构如下

刚开始，Monitor 中 Owner 为 null
当 Thread-2 执行 synchronized(obj) 就会将 Monitor 的所有者置为 Thread-2,Monitor 中只能有一个 Owner
在 Thread-2 上锁的过程中，如果 Thread-3，Thread-4，Thread-5 也来执行 synchronized(obj)，就会进入EntryList BLOCKED
Thread-2 执行完同步代码块的内容，然后唤醒 EntryList 中等待的线程来竞争锁，竞争的时是非公平的
图中 WaitSet 中的 Thread-0，Thread-1 是之前获得过锁，但条件不满足进入 WAITING 状态的线程，后面再说

注意：

synchronized 必须是进入同一个对象的 monitor 才有上述的效果
不加 synchronized 的对象不会关联监视器，不遵从以上规则

synchronized 原理（重要）

加锁和释放锁的原理

参考上面的图

Monitorenter和Monitorexit指令，会让对象在执行，使其锁计数器加1或者减1。每一个对象在同一时间只与一个monitor(锁)相关联，而一个monitor在同一时间只能被一个线程获得，一个对象在尝试获得与这个对象相关联的Monitor锁的所有权的时候，monitorenter指令会发生如下3中情况之一：

monitor计数器为0，意味着目前还没有被获得，那这个线程就会立刻获得然后把锁计数器+1，一旦+1，别的线程再想获取，就需要等待
如果这个monitor已经拿到了这个锁的所有权，又重入了这把锁，那锁计数器就会累加，变成2，并且随着重入的次数，会一直累加
这把锁已经被别的线程获取了，等待锁释放

Monitorenter和Monitorexit指令其实就对应着上锁和解锁操作

可重入锁的原理

可重入锁：又名递归锁，是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁（前提锁对象得是同一个对象或者class），不会因为之前已经获取过还没释放而阻塞

public class SynchronizedDemo {

    public static void main(String[] args) {
        SynchronizedDemo demo =  new SynchronizedDemo();
        demo.method1();
    }

    private synchronized void method1() {
        System.out.println(Thread.currentThread().getId() + ": method1()");
        method2();
    }

    private synchronized void method2() {
        System.out.println(Thread.currentThread().getId()+ ": method2()");
        method3();
    }

    private synchronized void method3() {
        System.out.println(Thread.currentThread().getId()+ ": method3()");
    }
}

执行monitorenter获取锁
（monitor计数器=0，可获取锁）
执行method1()方法，monitor计数器+1 -> 1 （获取到锁）
执行method2()方法，monitor计数器+1 -> 2
执行method3()方法，monitor计数器+1 -> 3
执行monitorexit命令
method3()方法执行完，monitor计数器-1 -> 2
method2()方法执行完，monitor计数器-1 -> 1
method2()方法执行完，monitor计数器-1 -> 0 （释放了锁）
（monitor计数器=0，锁被释放了）

这就是Synchronized的重入性，即在同一锁程中，每个对象拥有一个monitor计数器，当线程获取该对象锁后，monitor计数器就会加一，释放锁后就会将monitor计数器减一，线程不需要再次获取同一把锁。

可见性的原理

Synchronized的happens-before规则

synchronized 锁优化

前置知识：对象头的概念

JVM 为对象分配内存之后，都初始化为零值（不使用 TLAB 情况 [TLAB: 本地线程分配缓冲 ]）

接下来，JVM 要对对象进行必要的设置，例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码（实际上对象的哈希码会延后到真正调用 Object::hashcode（）方法时才会计算）、对象的 GC 年龄分代信息等。

这些信息全部存放到对象的对象头（Object Header ）中。

对象头中的数据可以总结为三类

第一类：Mark Word	hashcode、分代年龄、锁信息
第二类：Class Pointer	指向方法区中 Class 对象，JVM 用来判断属于哪个类
第三类：数组长度	前提是该对象是数组

|--------------------------------------------------------------|
|                     Object Header (64 bits)                  |
|------------------------------------|-------------------------|
|        Mark Word (32 bits)         |    Klass Word (32 bits) |
|------------------------------------|-------------------------|

|---------------------------------------------------------------------------------|
|                                 Object Header (96 bits)                         |
|--------------------------------|-----------------------|------------------------|
|        Mark Word(32bits)       |    Klass Word(32bits) |  array length(32bits)  |
|--------------------------------|-----------------------|------------------------|

而与 Synchronized 关系最大的就是 Mark Word 中的锁信息