Synchronized 的底层原理——Java全栈知识（40）

最新推荐文章于 2024-09-14 21:48:00 发布
最新推荐文章于 2024-09-14 21:48:00 发布
阅读量299 收藏 3
点赞数 5
分类专栏： Java全栈知识 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dghehe/article/details/141087771
版权

Synchronized 的底层原理

1、Synchronized 如何使用？

我们都知道 Synchronized 关键字会给代码上互斥锁，但是上锁的位置分为两种，分别是对象锁和类锁

1.1、对象锁

1、Synchronized 默认锁的对象是 this，也可以手动指定锁对象。
案例一（锁 this 对象）：

public class SynchronizedObjectLock implements Runnable {  
    static SynchronizedObjectLock instance = new SynchronizedObjectLock();  
  
    @Override  
    public void run() {  
        // 同步代码块形式——锁为this,两个线程使用的锁是一样的,线程1必须要等到线程0释放了该锁后，才能执行  
        synchronized (this) {  
            System.out.println("我是线程" + Thread.currentThread().getName());  
            try {  
                Thread.sleep(3000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            System.out.println(Thread.currentThread().getName() + "结束");  
        }  
    }  
  
    public static void main(String[] args) {  
        Thread t1 = new Thread(instance);  
        Thread t2 = new Thread(instance);  
        t1.start();  
        t2.start();  
    }  
}

运行结果是：


我是线程Thread-0
Thread-0结束
我是线程Thread-1
Thread-1结束

[!note]

1、我们可以看到 t 1 运行时锁住了 instance 对象

2、t 2 开始运行获取当前对象的锁

3、阻塞等待到 t 1 释放锁，t 2 获取锁执行。

2、Synchronized 指定锁对象

案例二（指定锁对象）：

public class SynchronizedObjectLock implements Runnable {  
    static SynchronizedObjectLock instance = new SynchronizedObjectLock();  
    // 创建2把锁  
    Object block1 = new Object();  
    Object block2 = new Object();  
  
    @Override  
    public void run() {  
        // 这个代码块使用的是第一把锁，当他释放后，后面的代码块由于使用的是第二把锁，因此可以马上执行  
        synchronized (block1) {  
            System.out.println("block1锁,我是线程" + Thread.currentThread().getName());  
            try {  
                Thread.sleep(3000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            System.out.println("block1锁,"+Thread.currentThread().getName() + "结束");  
        }  
  
        synchronized (block2) {  
            System.out.println("block2锁,我是线程" + Thread.currentThread().getName());  
            try {  
                Thread.sleep(3000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            System.out.println("block2锁,"+Thread.currentThread().getName() + "结束");  
        }  
    }  
  
    public static void main(String[] args) {  
        Thread t1 = new Thread(instance);  
        Thread t2 = new Thread(instance);  
        t1.start();  
        t2.start();  
    }  
}


block1锁,我是线程Thread-0  
block1锁,Thread-0结束  
block2锁,我是线程Thread-0　　// 可以看到当第一个线程在执行完第一段同步代码块之后，第二个同步代码块可以马上得到执行，因为他们使用的锁不是同一把  
block1锁,我是线程Thread-1  
block2锁,Thread-0结束  
block1锁,Thread-1结束  
block2锁,我是线程Thread-1  
block2锁,Thread-1结束

[!note]

1、t 1 线程获取到 block 1，t 2 线程阻塞等待

2、t 1 线程释放 block 1 获取到 block 2，t 2 获取到 block1

3、t 1 线程释放 block 2 ，t 2 线程获取到 block 2 执行

3、方法锁：synchronized 修饰普通方法，锁对象默认为 this

案例三：

public class SynchronizedObjectLock implements Runnable {  
    static SynchronizedObjectLock instance = new SynchronizedObjectLock();  
  
    @Override  
    public void run() {  
        method();  
    }  
  
    public synchronized void method() {  
        System.out.println("我是线程" + Thread.currentThread().getName());  
        try {  
            Thread.sleep(3000);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        System.out.println(Thread.currentThread().getName() + "结束");  
    }  
  
    public static void main(String[] args) {  
        Thread t1 = new Thread(instance);  
        Thread t2 = new Thread(instance);  
        t1.start();  
        t2.start();  
    }  
}

运行结果是：


我是线程Thread-0
Thread-0结束
我是线程Thread-1
Thread-1结束

1.2、类锁

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

1、 synchronize 修饰静态方法

示例一（修饰普通方法）：

public class SynchronizedObjectLock implements Runnable {
    static SynchronizedObjectLock instance1 = new SynchronizedObjectLock();
    static SynchronizedObjectLock instance2 = new SynchronizedObjectLock();

    @Override
    public void run() {
        method();
    }

    // synchronized用在普通方法上，默认的锁就是this，当前实例
    public synchronized void method() {
        System.out.println("我是线程" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "结束");
    }

    public static void main(String[] args) {
        // t1和t2对应的this是两个不同的实例，所以代码不会串行
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
    }
}

输出结果：

我是线程Thread-0
我是线程Thread-1
Thread-1结束
Thread-0结束
  • 示例2（synchronized 修饰静态方法）
public class SynchronizedObjectLock implements Runnable {
    static SynchronizedObjectLock instance1 = new SynchronizedObjectLock();
    static SynchronizedObjectLock instance2 = new SynchronizedObjectLock();

    @Override
    public void run() {
        method();
    }

    // synchronized用在静态方法上，默认的锁就是当前所在的Class类，所以无论是哪个线程访问它，需要的锁都只有一把
    public static synchronized void method() {
        System.out.println("我是线程" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "结束");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
    }
}

输出结果：

我是线程Thread-0
Thread-0结束
我是线程Thread-1
Thread-1结束

[!note]

synchronized 用在静态方法上，默认的锁就是当前所在的 Class 类，所以无论是哪个线程访问它，需要的锁都只有一把

2 、 synchronized 修饰 Class 对象

public class SynchronizedObjectLock implements Runnable {
    static SynchronizedObjectLock instance1 = new SynchronizedObjectLock();
    static SynchronizedObjectLock instance2 = new SynchronizedObjectLock();

    @Override
    public void run() {
        // 所有线程需要的锁都是同一把
        synchronized(SynchronizedObjectLock.class){
            System.out.println("我是线程" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "结束");
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
    }
}

输出结果：

我是线程Thread-0
Thread-0结束
我是线程Thread-1
Thread-1结束

[!note]

synchronized (SynchronizedObjectLock. class)锁的是当前类。

2、 synchronized 的原理

2.1、Monitor

Monitor 被翻译为监视器，是由 jvm 提供，c++语言实现
在代码中想要体现monitor需要借助javap命令查看clsss的字节码，比如以下代码：

public class SyncTest {  
​  
    static final Object lock = new Object();  
    static int counter = 0;  
    public static void main(String[] args) {  
        synchronized (lock) {  
            counter++;  
        }  
    }  
}

找到这个类的class文件，在class文件目录下执行javap -v SyncTest.class，反编译效果如下：
image-20230504165342501

monitorenter 上锁开始的地方
monitorexit 解锁的地方
其中被 monitorenter 和 monitorexit 包围住的指令就是上锁的代码
有两个monitorexit的原因，第二个monitorexit是为了防止锁住的代码抛异常后不能及时释放锁

在使用了synchornized代码块时需要指定一个对象，所以synchornized也被称为对象锁
monitor主要就是跟这个对象产生关联，如下图
image-20230504165833809

[!note]
上面我们说了，synchronized 锁的是对象，所以说一个锁对应一个对象对应一个 Monitor

Monitor内部具体的存储结构：

  • Owner：存储当前获取锁的线程的，只能有一个线程可以获取
  • EntryList：关联没有抢到锁的线程，处于Blocked状态的线程
  • WaitSet：关联调用了wait方法的线程，处于Waiting状态的线程

具体的流程：

  • 代码进入synchorized代码块，先让lock（对象锁）关联的monitor，然后判断Owner是否有线程持有
  • 如果没有线程持有，则让当前线程持有，表示该线程获取锁成功
  • 如果有线程持有，则让当前线程进入entryList进行阻塞，如果Owner持有的线程已经释放了锁，在EntryList中的线程去竞争锁的持有权（非公平）
  • 如果代码块中调用了wait()方法，则会进去WaitSet中进行等待

总结：

  • Synchronized【对象锁】采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】
  • 它的底层由monitor实现的，monitor是jvm级别的对象（ C++实现），线程获得锁需要使用对象（锁）关联monitor
  • 在monitor内部有三个属性，分别是owner、entrylist、waitset
  • 其中owner是关联的获得锁的线程，并且只能关联一个线程；entrylist关联的是处于阻塞状态的线程；waitset关联的是处于Waiting状态的线程
东莞呵呵
关注
专栏目录
后端面试话术集锦第 十三 篇：java集合面试话术
念兮为美
09-01 349
后端面试话术集锦第 十三 篇：java集合面试话术。Java里常见的数据结构都有哪些以及特征；HashMap底层原理；介绍下ConcurrentHashMap；线程安全的HashMap类有哪些，ConcurrentHashMap如何保证线程安全； HashMap1.7与1.8的区别，说明1.8做了哪些优化，如何优化的
Java 学习路线大全，再也不用迷路啦（持续更新）
腾讯全栈-ITCJF
10-14 2755
路线特点 最新，完整一条龙，从入门到入土（⭐ 表示推荐学习） 给出目标、学习建议、关键知识点、最优资源以及各类资源推荐（视频、书籍、文档、项目、工具等） 划分阶段、更有计划，且在最后给出持续学习的方向、探索 Java 程序员发展的无限可能 前言 首先呢，我们要了解 Java 的应用场景和就业方向，看看和自己的学习目的是否一致，目前，Java 的岗位需求多，是后台开发的主流编程语言，功能强大，还是很值得学习的。 阶段 1：Java 入门 目标 培养兴趣、快速上手 前期准备 准备好一款在线、随时随地
ReentrantLock的原理——Java全栈知识（45）
dghehe的博客
08-17 308
可中断可以设置超时时间可以设置公平锁支持多个条件变量 （类似于 wait 等待）与 synchronized 一样，都支持重入注意：一定要去释放锁，要不然就会死锁。
ConcurrentHashMap原理分析——Java全栈知识（47）
dghehe的博客
09-06 334
ConcurrentHashMap 是一种线程安全的高效 Map 集合。
synchronized的底层原理
学习
02-19 480
synchronized使用方式 我们知道并发编程会产生各种问题的源头是可见性，原子性，有序性。 而synchronized能同时保证可见性，原子性，有序性。所以我们在解决并发问题的时候经常用synchronized，当然还有很多其他工具，如volatile。但是volatile只能保证可见性，有序性，不能保证原子性。参见之前的文章volatile关键字——保证并发编程中的可见性、有序性 sync...
Synchronized 底层原理总结
每日搜罗
09-08 285
一.synchronized介绍 synchronized是JVM内置锁，通过内部对象Monitor（监视器锁）来实现，基于进入与退出monitor对象来实现方法与代码块的同步，监视器锁的实现，最终依赖操作系统的Mutex lock（互斥锁）来实现。 二.synchronized使用方式 synchronized 主要有3种使用方式。 1.同步类方法 public synchronized void method() { // todo } 锁的是当前类对象； 2.同步代码块 public class
多线程与高并发（三）—— 源码解析 AQS 原理
m0_56069948的博客
07-28 284
AQS是一个同步框架，关于同步在操作系统（一）——进程同步中对进程同步做了些概念性的介绍，我们了解到进程（线程同理，本文基于JVM讲解，故下文只称线程）同步的工具有很多但是Mutex和Semaphore作为低级通信存在不少缺点，Monitor机制解决了上面部分缺憾，但是仍然存在问题，AQS的出现很好的解决了这些问题。AQS即一个类，java.util.concurrent.AbstractQueuedSynchronized.Class，这个类作为一个构造同步器的框架。https。...
Java学习教程，Java从入门到精通，全套Java视频教程+笔记+配套工具
Java___interview的博客
07-20 947
目录 一、大纲 一、Java基础 二、计算机基础 三、工具的使用 四、数据库 五、web前端 六、JavaWeb 七、框架 八、互联网分布式技术 发现身边很多自学java却放弃的，真的挺可惜的。 白白浪费了几个月宝贵的时间，且放弃一次，就会有下一次。 如何学习Java并成功？——要有一个清晰的目标！ 比如培训还是其他学习方式，都是达成目标的一个方法，这个方法不够，可以找别的方法来达成目标。 所以，在学Java前希望你想清楚，你想不想成为一个程序员，想得话就做好准备，知道自己选
2022年学go还是java？
m0_57290404的博客
08-18 1131
Java仍然是主流的企业级应用编程语言，比如像传统的ERP，OA，CRM这些信息化系统还是会用Java作为主要语言，看看阿里，华为，金蝶等大厂的招聘岗位就知道了。而Go语言代表了未来，很多新兴上市公司都在使用Go做主编程语言。Go致力于使事情简单化，它只提供了基本功能，没有多余，在性能这块，当前我们使用 Go 编写的最大微服务的编译时间只需 6 秒。相较于 Java 和 C++呆滞的编译速度，Go 的快速编译时间是一个主要的效率优势。......
Java-网络
2301_81543552的博客
09-14 388
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 371
如果在新建Android项目时报错：Read timed out或者connect timed out。
上传文件到钉盘流程详解
jspyth的博客
09-14 474
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 598
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
面试题篇: 跨域问题如何处理(Java和Nginx处理方式)
最新发布
m0_66572126的博客
09-14 489
最常见的解决方案是在服务器端配置 CORS 头。服务器需要在响应中添加适当的 Access-Control-Allow-头来允许跨域请求。
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 773
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
C#基础（11）函数重载
a6s686的博客
09-12 806
我们通过这些例子的学习，想毕你一定已经掌握了函数重载的相关内容，我相信你只要稍加练习，便能达到很熟练的程度。不过不管知识点难或者简单，还是那句话，学习路上，戒骄戒躁，脚踏实地。请期待我的下一篇博客！
Spring AMQP给消息添加头信息
yong472727322的博客
09-10 277
【代码】Spring AMQP给消息添加头信息。
Spring-di基本使用
2301_76862031的博客
09-09 1409
spirngDi环境搭建，使用流程，set注入，构造注入，对象注入，外部引入注入，内部创建注入，外部引入级联赋值注入，list集合注入，map集合注入，util注入
java中synchronized底层原理是什么
07-22
Java中synchronized的底层原理是基于对象监视器（Object Monitor）实现的。 每个Java对象都有一个与之关联的监视器锁（Monitor Lock），也称为内置锁（Intrinsic Lock）或互斥锁（Mutex Lock）。当一个线程试图进入一个synchronized方法或代码块时，它会尝试获取该方法或代码块所关联对象的监视器锁。 当一个线程成功获取锁后，它可以执行同步代码。其他线程如果想要获取同一个锁，就必须等待该线程释放锁。这样可以确保同一时间只有一个线程能够执行被锁定的代码，从而实现了线程安全。 底层实现中，监视器锁的获取和释放是通过底层操作系统的互斥原语来实现的。具体地说，当一个线程获取锁时，它会尝试将对象的监视器锁标记为已占用。如果锁已经被其他线程占用，那么获取锁的线程就会被阻塞，直到锁被释放。 在Java虚拟机中，对象监视器的实现通常包括一个等待队列（Waiting Queue）和一个通知队列（Notification Queue）。等待队列用于存放那些尝试获取锁但未成功的线程，而通知队列用于存放那些等待被唤醒的线程。 当一个线程释放锁时，它会将锁的状态设置为可用，并且从等待队列中选择一个线程进行唤醒，使其有机会获取锁。被唤醒的线程会进入到就绪状态，然后与其他线程竞争获取锁。 总之，Java中synchronized的底层原理是通过对象监视器实现的，依赖于操作系统提供的互斥原语来实现线程同步和互斥访问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

东莞呵呵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值