【JavaEE】Java中复杂的Synchronized关键字

这篇具有很好参考价值的文章主要介绍了【JavaEE】Java中复杂的Synchronized关键字。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

 一、synchronized的特性

(1)互斥

(2)刷新内存

(3)可重入

二、synchronized的使用

(1)修饰普通方法

(2)修饰静态方法

(3)修饰代码块

三、synchronized的锁机制

(1)基本特点

(2)加锁工作过程

1.偏向锁

2.轻量级锁

3.重量级锁

(3)优化操作

1.锁消除

2.锁粗化

四、synchronized和volatile的区别


 文章来源地址https://www.toymoban.com/news/detail-803304.html

 一、synchronized的特性

(1)互斥

         synchronized 通过互斥达到原子性(线程安全的四大特性之一)

        synchronized 会起到互斥效果,某个线程执行到某个对象的 synchronized 中时,其他线程如果也执行到同一个对象 synchronized 就会阻塞等待。同一时间,只能一个线程拥有这把锁,去执行代码。
1.进入 synchronized 修饰的代码块, 相当于 加锁。
2.退出 synchronized 修饰的代码块, 相当于 解锁。

synchronized void increase(){//进入方法内部,相当于针对当前对象 
        count++;

}//执行完毕相当于针对当前对象“解锁”

        synchronized用的锁是存在Java对象头里的。synchronized的底层是使用操作系统的mutex lock实现的。
        可以粗略理解成, 每个对象在内存中存储的时候, 都存有一块内存表示当前的 "锁定" 状态。如果当前是 "未锁定" 状态, 那么就可以使用, 使用时需要设为 "锁定" 状态。如果当前是 "锁定" 状态, 那么其他人无法使用, 只能排队等待。一个线程先上了锁,其他线程只能等待这个线程释放。

        注意点:

        针对每一把锁,操作系统内部都维护了一个等待队列。当这个锁被某个线程占有的时候, 其他线程尝试进行加锁,就加不上了, 就会阻塞等待, 一直等到之前的线程解锁之后,由操作系统唤醒一个新的线程,再来获取到这个锁。

        上一个线程解锁之后, 下一个线程并不是立即就能获取到锁。而是要靠操作系统来 "唤醒"。 这也就是操作系统线程调度的一部分工作。
        假设有 A B C 三个线程,线程 A 先获取到锁,然后 B 尝试获取锁, 然后 C 再尝试获取锁,此时 B和 C 都在阻塞队列中排队等待。 但是当 A 释放锁之后, 虽然 B 比 C 先来的, 但是 B 不一定就能获取到锁, 而是和 C 重新竞争,并不遵守先来后到的规则

(2)刷新内存

        synchronized 通过加锁减锁能保证内存可见性。

synchronized 的工作过程:
1. 获得互斥锁
2. 从主内存拷贝变量的最新副本到工作的内存
3. 执行代码
4. 将更改后的共享变量的值刷新到主内存
5. 释放互斥锁
所以 synchronized 也能保证内存可见性。

(3)可重入

         synchronized 只能有一定约束,并不能完全禁止指令重排序。synchronized 同步块对同一条线程来说是可重入的,不会出现自己把自己锁死的问题。

// 第一次加锁, 加锁成功
lock();
// 第二次加锁, 锁已经被占用, 阻塞等待.
lock();

        对于把自己锁死,就是一个线程没有释放锁,然后又尝试再次加锁。

        按照之前对于锁的设定, 第二次加锁的时候会阻塞等待。直到第一次的锁被释放, 才能获取到第二个锁。释放第一个锁也是由该线程来完成, 结果这个线程已经阻塞等待了,也就无法进行解锁操作。这时候就会死锁。这样的锁称为不可重入锁。

        Java中的synchronized是可重入锁,因此不会出现上述问题。可重入锁的内部,包含了 "线程持有者" 和 "计数器" 两个信息。如果某个线程进行加锁的时候, 发现锁已经被人占用, 占用者恰好是自己,那么仍然可以继续获取到锁, 并让计数器自增。解锁的时候就是当计数器递减为0的时候, 才真正释放锁,这时候锁才能被别的线程获取到。

二、synchronized的使用

(1)修饰普通方法

锁的 SynchronizedDemo 对象

public class SynchronizedDemo {
    public synchronized void methond() {
    }
}

(2)修饰静态方法

锁的 SynchronizedDemo 类的对象
 

public class SynchronizedDemo {
    public synchronized static void method() {
    }
}

(3)修饰代码块

明确指定锁的对象

锁当前对象

public class SynchronizedDemo {
    public void method() {
    synchronized (this) {
        }
    }
}

锁类对象

public class SynchronizedDemo {
    public void method() {
        synchronized (SynchronizedDemo.class) {
        }
    }
}

        需要注意的是两个线程竞争同一把锁,才会产生阻塞等待。两个线程分别尝试获取两把不同的锁,不会产生竞争。

三、synchronized的锁机制

(1)基本特点

        只考虑 JDK 1.8,加锁工作过程:JVM 将 synchronized 锁分为 无锁、偏向锁、轻量级锁、重量级锁 状态。会根据情况,进行依次升级。
1. 开始时是乐观锁, 如果锁冲突频繁, 就转换为悲观锁.
2. 开始是轻量级锁实现, 如果锁被持有的时间较长, 就转换成重量级锁.
3. 实现轻量级锁的时候大概率用到的自旋锁策略
4. 是一种不公平锁
5. 是一种可重入锁
6. 不是读写锁

(2)加锁工作过程

1.偏向锁

        第一个尝试加锁的线程,优先进入偏向锁状态。
        偏向锁不是真的 "加锁", 只是给对象头中做一个 "偏向锁的标记",记录这个锁属于哪个线程。如果后续没有其他线程来竞争该锁,那么就不用进行其他同步操作了,避免了加锁解锁的开销。如果后续有其他线程来竞争该锁,因为刚才已经在锁对象中记录了当前锁属于哪个线程了, 很容易识别当前申请锁的线程是不是之前记录的线程, 那就取消原来的偏向锁状态, 进入一般的轻量级锁状态。偏向锁本质上相当于 "延迟加锁"。能不加锁就不加锁,尽量来避免不必要的加锁开销。但是该做的标记还是得做的, 否则无法区分何时需要真正加锁。

        面试中会经常问到什么是偏向锁。偏向锁不是真的加锁,而只是在锁的对象头中记录一个标记,记录该锁所属的线程。如果没有其他线程参与竞争锁,那么就不会真正执行加锁操作,从而降低程序开销。一旦真的涉及到其他的线程竞争,再取消偏向锁状态,进入轻量级锁状态。

2.轻量级锁

        随着其他线程进入竞争,偏向锁状态被消除, 进入轻量级锁状态(自适应的自旋锁)。
此处的轻量级锁就是通过 CAS 来实现。
        通过 CAS 检查并更新一块内存 (比如 null => 该线程引用)。如果更新成功,则认为加锁成功。如果更新失败, 则认为锁被占用, 继续自旋式的等待(并不放弃 CPU)。
自旋操作是一直让 CPU 空转, 比较浪费 CPU 资源。因此此处的自旋不会一直持续进行, 而是达到一定的时间、重试次数, 就不再自旋了。也就是所谓的 "自适应"

3.重量级锁

        如果竞争进一步激烈, 自旋不能快速获取到锁状态,就会膨胀为重量级锁。此处的重量级锁就是指用到内核提供的 mutex。
        执行加锁操作, 先进入内核态。在内核态判定当前锁是否已经被占用。如果该锁没有占用, 则加锁成功, 并切换回用户态。如果该锁被占用,则加锁失败。 此时线程进入锁的等待队列、挂起。 等待被操作系统唤醒。经历了一系列的操作, 这个锁被其他线程释放了, 操作系统也想起了这个挂起的线程,于是唤醒。这个线程, 尝试重新获取锁。

(3)优化操作

1.锁消除

编译器+JVM 判断锁是否可消除。 如果可以, 就直接消除。

锁消除:有些应用程序的代码中, 用到了 synchronized, 但其实没有在多线程环境下。 (例如StringBuffer)此时每个 append 的调用都会涉及加锁、解锁。但如果只是在单线程中执行这个代码, 那么这些加锁解锁操作是没有必要的,,白白浪费了一些资源开销。可以进行消除操作。
StringBuffer sb = new StringBuffer();
sb.append("a");
sb.append("b");
sb.append("c");
sb.append("d");

2.锁粗化

一段逻辑中如果出现多次加锁解锁,编译器 + JVM 会自动进行锁的粗化。

锁的粒度: 粗和细

        实际开发过程中,使用细粒度锁,是期望释放锁的时候其他线程能使用锁。但是实际上可能并没有其他线程来抢占这个锁。这种情况 JVM 就会自动把锁粗化, 避免频繁申请释放锁。例如给下属交代工作任务:方式一:打电话,交代任务1, 挂电话。打电话,交代任务2,挂电话。打电话, 交代任务3, 挂电话。方式二:打电话,交代任务1,任务2,任务3,挂电话。显然,方式二是更高效的方案。这就是锁粗化的一个过程。

四、synchronized和volatile的区别

        synchronized和volatile都是Java关键字,并且都是解决线程安全的

 的方式,所以在面试的时候经常会被放到一起问。

        两者其实并没有联系。

        synchronized:

        1.通过加锁、解锁的方式,把一堆代码绑在一起,来保证原子性。

        2.通过加锁、解锁的方式, 来保证内存可见性。

        3.对指令重排序有一定约束。

        volatile:

        1.不能保证原子性。

        2.保证内存可见性。

        3.禁止指令重排序。       

       虽然synchronized在大多数情况下,都可以保证线程安全的。但是也不能在任何情况下都用synchronized的。synchronized是要付出一定代价的。synchronized是通过加锁、解锁的方式来保证的。所以,其他线程抢不到锁的时候,线程就会阻塞。线程就会放弃CPU,放弃之后,被重新调用的时间是不确定的。当使用synchronized就一定程度上放弃了高性能。使用volatile不会造成线程阻塞,但对性能也有一定影响,不过没有synchronized影响大。

        使用多线程是为了提高效率。使用synchronized,就代表放弃了一定效率。这两者需要平衡。      


java synchronized特性,JavaEE,java,java-ee,开发语言,jvm,面试

 

 

到了这里,关于【JavaEE】Java中复杂的Synchronized关键字的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Synchronized关键字】

    Synchronized是Java中的,它用于控制多线程之间的访问,保证同一时刻只有一个线程可以执行被锁定的代码块或方法。在多线程编程中,Synchronized是一种非常重要的机制,它可以避免多个线程同时访问共享资源而产生数据不一致性的问题。 Synchronized有两种使用方式:对代

    2024年02月08日
    浏览(42)
  • 并发——synchronized 关键字

    synchronized 解决的是多个线程之间访问资源的同步性, synchronized 可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外,在 Java 早期版本中, synchronized 属于 重量级锁 ,效率低下。 为什么呢? 因为监视器锁(monitor)是依赖于底层的操作系

    2024年02月13日
    浏览(33)
  • 线程中synchronized关键字和lock接口的异同

    一、synchronized 1.可以用来修饰代码块  2.可以用在方法上 修饰同步方法 while (true) { try { Thread.sleep(200); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } if(sellTicket()) { break; } } 二、lock接口  1.用此接口要用     ReentrantLock l = new ReentrantLock();     

    2024年02月08日
    浏览(43)
  • 线程的状态,多线程带来的风险,synchronized关键字及死锁问题

    目录 状态  线程的意义 多线程带来的风险——线程安全✅ 线程安全的概念 线程不安全的原因 抢占式执行,随机性调度 修改共享数据 原子性-加🔒 可见性 指令重排序 解决线程不安全问题(学完线程再总结) synchronized——监视器锁monitor lock​编辑   互斥 使用示例

    2024年02月06日
    浏览(51)
  • [JAVAee]volatile关键字

    目录 1.volatile的特性 ①保持线程可见性 2.volatile注意事项及适用场景 ①注意事项 ②适用场景 volatile,译为\\\"易变的\\\". 对此我们就可以这样理解,对于被volatile修饰的变量的数值,是容易变化的. 在之前的线程安全文章中,我们有讲解过\\\"可见性\\\",对于线程间的这个特性可能会导致:线程

    2024年02月16日
    浏览(36)
  • 《吊打面试官系列》从源码全面解析 synchronized 关键字的来龙去脉

    👏作者简介:大家好,我是爱敲代码的小黄,独角兽企业的Java开发工程师,CSDN博客专家,阿里云专家博主 📕系列专栏:Java设计模式、数据结构和算法、Kafka从入门到成神、Kafka从成神到升仙、Spring从成神到升仙系列 🔥如果感觉博主的文章还不错的话,请👍三连支持👍一

    2023年04月16日
    浏览(46)
  • Java ---一些关键字

     ①含义: this:当前对象 在构造器和非静态代码块中,表示正在new的对象 在实例方法中,表示调用当前方法的对象 ②this用法: this.成员变量:表示当前对象的某个成员变量,而不是局部变量 this.成员方法:表示当前对象的某个成员方法,完全可以省略this. this()或this(实参列

    2023年04月09日
    浏览(41)
  • 【Java入门】final关键字、static关键字、内部类的认识

    前言 : final是Java中的一个修饰符,用于表示某个变量、方法或者类不能被修改。final可以用于修饰类、方法和变量(局部变量,成员变量)。被final所修饰的类不能被继承,被final所修饰的方法不能被重写,被final所修饰的变量,不能被重新赋值 。 static是Java中的一

    2024年02月11日
    浏览(51)
  • JAVA volatile 关键字

    volatile 是JAVA虚拟机提供的轻量级的同步机制,有三大特性 1、保证可见性  2、不保证原子性  3、禁止指令重排 JMM  JAVA内存模型本身是一种抽象的概念并不真实存在 它描述的是一组规则或规范,提供这组规范定义了程序中各个变量(包括实例变量、静态变量)的访问方式。

    2024年02月13日
    浏览(50)
  • 【java】static关键字

    类与对象的关系 类是构建对象的模板,一个类可以构建多个对象。 类在 方法区 当中,对象在 堆 中。 static修饰的变量是 独属于类 的变量,没有给对象。 运行结果  static修饰的变量究竟储存在什么地方 在 方法区 当中有 静态常量池 ,static修饰的变量被放在静态常量池中,

    2024年04月15日
    浏览(31)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包