精华内容
下载资源
问答
  • 2019-10-12 10:31:14

    一、锁种类

    偏向锁

    因为经过HotSpot的作者大量的研究发现,大多数时候是不存在锁竞争的,常常是一个线程多次获得同一个锁,因此如果每次都要竞争锁会增大很多没有必要付出的代价,为了降低获取锁的代价,才引入的偏向锁。

    轻量级锁

    轻量级锁考虑的是竞争锁对象的线程不多,而且线程持有锁的时间也不长的情景。因为阻塞线程需要CPU从用户态转到内核态,代价较大,如果刚刚阻塞不久这个锁就被释放了,那这个代价就有点得不偿失了,因此这个时候就干脆不阻塞这个线程,让它自旋这等待锁释放。

    自旋锁

    减少线程上下文切换,提高执行效率

    重量级锁

    除拥有锁的线程外阻塞所有竞争线程

    二、具体过程

    1. 线程A在进入同步代码块前,先检查MarkWord中的线程ID是否与当前线程ID一致,如果一致(还是线程A获取锁对象),则无需使用CAS来加锁、解锁。
    2. 如果不一致,再检查是否为偏向锁,如果不是,则自旋等待锁释放。
    3. 如果是,再检查该线程是否存在(偏向锁不会主动释放锁),如果不在,则设置线程ID为线程A的ID,此时依然是偏向锁。
    4. 如果还在,则暂停该线程,同时将锁标志位设置为00即轻量级锁(将MarkWord复制到该线程的栈帧中并将MarkWord设置为栈帧中锁记录)。线程A自旋等待锁释放。
    5. 如果自旋次数到了该线程还没有释放锁,或者该线程还在执行,线程A还在自旋等待,这时又有一个线程B过来竞争这个锁对象,那么这个时候轻量级锁就会膨胀为重量级锁。重量级锁把除了拥有锁的线程都阻塞,防止CPU空转。
    6. 如果该线程释放锁,则会唤醒所有阻塞线程,重新竞争锁。
    更多相关内容
  • Java 锁升级过程

    2021-12-01 11:28:55
    java中对象锁有4种状态:(级别从低到高) 1.无锁状态 2.偏向锁状态 3.轻量级锁状态 4.重量级锁状态 对象头分两部分信息,第一部分用于存储哈希码、GC分代年龄等,这部分数据被称为"Mark ...锁升级的方向是:无锁——

    java中对象锁有4种状态:(级别从低到高)
    1.无锁状态
    2.偏向锁状态
    3.轻量级锁状态
    4.重量级锁状态

    对象头分两部分信息,第一部分用于存储哈希码、GC分代年龄等,这部分数据被称为"Mark Word"。在32位的HotSpot虚拟机中对象未被锁定的状态下,Mark Word的32bit空间中的25bit用于存储对象哈希码,4bit用于存储对象分代年龄,2bit用于存储锁标志位,1bit固定为0,在其他状态(轻量级锁定、重量级锁定、GC标记、可偏向)下对象的存储内容见下表:

    锁升级的方向是:无锁——>偏向锁——>轻量级锁——>重量级锁,并且膨胀方向不可逆。

    1.偏向锁
    偏向锁是JDK6中引入的一项锁优化,大多数情况下,锁不仅不存在多线程竞争,而且总是由同一线程多次获得,为了让线程获得锁的代价更低而引入了偏向锁。
    偏向锁会偏向于第一个获得它的线程,如果在接下来的执行过程中,该锁没有被其他的线程获取,则持有偏向锁的线程将永远不需要同步。

    2.轻量级锁
    如果明显存在其它线程申请锁,那么偏向锁将很快升级为轻量级锁。

    3.自旋锁
    自旋锁原理非常简单,如果持有锁的线程能在很短时间内释放锁资源,那么那些等待竞争锁的线程就不需要做内核态和用户态之间的切换进入阻塞挂起状态,它们只需要等一等(自旋),等持有锁的线程释放锁后即可立即获取锁,这样就避免用户线程和内核的切换的消耗。

    4.重量级锁
    指的是原始的Synchronized的实现,重量级锁的特点:其他线程试图获取锁时,都会被阻塞,只有持有锁的线程释放锁之后才会唤醒这些线程。

     

    展开全文
  • java锁升级过程

    万次阅读 多人点赞 2020-03-14 20:32:17
    java中对象有4种状态:(级别从低到高) 1.无锁状态 2.偏向状态 3.轻量级状态 4.重量级状态 对象头分两部分信息,第一部分用于存储哈希码、GC分代年龄等,这部分数据被称为"Mark Word"。在32位的HotSpot...

    java中对象锁有4种状态:(级别从低到高)
    1.无锁状态
    2.偏向锁状态
    3.轻量级锁状态
    4.重量级锁状态

    对象头分两部分信息,第一部分用于存储哈希码、GC分代年龄等,这部分数据被称为"Mark Word"。在32位的HotSpot虚拟机中对象未被锁定的状态下,Mark Word的32bit空间中的25bit用于存储对象哈希码,4bit用于存储对象分代年龄,2bit用于存储锁标志位,1bit固定为0,在其他状态(轻量级锁定、重量级锁定、GC标记、可偏向)下对象的存储内容见下表:
    在这里插入图片描述
    锁升级的方向是:无锁——>偏向锁——>轻量级锁——>重量级锁,并且膨胀方向不可逆。

    1.偏向锁
    偏向锁是JDK6中引入的一项锁优化,大多数情况下,锁不仅不存在多线程竞争,而且总是由同一线程多次获得,为了让线程获得锁的代价更低而引入了偏向锁。
    偏向锁会偏向于第一个获得它的线程,如果在接下来的执行过程中,该锁没有被其他的线程获取,则持有偏向锁的线程将永远不需要同步。

    2.轻量级锁
    如果明显存在其它线程申请锁,那么偏向锁将很快升级为轻量级锁。

    3.自旋锁
    自旋锁原理非常简单,如果持有锁的线程能在很短时间内释放锁资源,那么那些等待竞争锁的线程就不需要做内核态和用户态之间的切换进入阻塞挂起状态,它们只需要等一等(自旋),等持有锁的线程释放锁后即可立即获取锁,这样就避免用户线程和内核的切换的消耗。

    4.重量级锁
    指的是原始的Synchronized的实现,重量级锁的特点:其他线程试图获取锁时,都会被阻塞,只有持有锁的线程释放锁之后才会唤醒这些线程。

    锁升级场景:

    场景1: 程序不会有锁的竞争。
    那么这种情况我们不需要加锁,所以这种情况下对象锁状态为无锁。

    场景2: 经常只有某一个线程来加锁。
    加锁过程:也许获取锁的经常为同一个线程,这种情况下为了避免加锁造成的性能开销,所以并不会加实际意义上的锁,偏向锁的执行流程如下:
    1、线程首先检查该对象头的线程ID是否为当前线程;
    2、A:如果对象头的线程ID和当前线程ID一直,则直接执行代码;B:如果不是当前线程ID则使用CAS方式替换对象头中的线程ID,如果使用CAS替换不成功则说明有线程正在执行,存在锁的竞争,这时需要撤销偏向锁,升级为轻量级锁。
    3、如果CAS替换成功,则把对象头的线程ID改为自己的线程ID,然后执行代码。
    4、执行代码完成之后释放锁,把对象头的线程ID修改为空。

    场景3: 有线程来参与锁的竞争,但是获取锁的冲突时间很短。
    当开始有锁的冲突了,那么偏向锁就会升级到轻量级锁;线程获取锁出现冲突时,线程必须做出决定是继续在这里等,还是回家等别人打电话通知,而轻量级锁的路基就是采用继续在这里等的方式,当发现有锁冲突,线程首先会使用自旋的方式循环在这里获取锁,因为使用自旋的方式非常消耗CPU,当一定时间内通过自旋的方式无法获取到锁的话,那么锁就开始升级为重量级锁了。

    场景4: 有大量的线程参与锁的竞争,冲突性很高。
    我们知道当获取锁冲突多,时间越长的时候,我们的线程肯定无法继续在这里死等了,所以只好先休息,然后等前面获取锁的线程释放了锁之后再开启下一轮的锁竞争,而这种形式就是我们的重量级锁。

    展开全文
  • Java锁升级的实现过程

    2020-08-19 04:53:59
    主要介绍了Java锁升级的实现过程,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了Java synchronized锁升级jol过程详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java锁升级过程

    千次阅读 2021-10-05 16:30:24
    一、锁升级 为什么要引入偏向锁? 因为经过HotSpot的作者大量的研究发现,大多数时候是不存在锁竞争的,常常是一个线程多次获得同一个锁,因此如果每次都要竞争锁会增大很多没有必要付出的代价,为了降低获取锁的...

    锁的4中状态:

    无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态(级别从低到高)

    一、锁升级

    1. 为什么要引入偏向锁?

    因为经过HotSpot的作者大量的研究发现,大多数时候是不存在锁竞争的,常常是一个线程多次获得同一个锁,因此如果每次都要竞争锁会增大很多没有必要付出的代价,为了降低获取锁的代价,才引入的偏向锁。

    1. 偏向锁的升级

    当线程1访问代码块并获取锁对象时,会在java对象头和栈帧中记录偏向的锁的threadID,因为偏向锁不会主动释放锁,因此以后线程1再次获取锁的时候,需要比较当前线程的threadID和Java对象头中的threadID是否一致,如果一致(还是线程1获取锁对象),则无需使用CAS来加锁、解锁;如果不一致(其他线程,如线程2要竞争锁对象,而偏向锁不会主动释放因此还是存储的线程1的threadID),那么需要查看Java对象头中记录的线程1是否存活,如果没有存活,那么锁对象被重置为无锁状态,其它线程(线程2)可以竞争将其设置为偏向锁;如果存活,那么立刻查找该线程(线程1)的栈帧信息,如果还是需要继续持有这个锁对象,那么暂停当前线程1,撤销偏向锁,升级为轻量级锁,如果线程1 不再使用该锁对象,那么将锁对象状态设为无锁状态,重新偏向新的线程。

    1. 偏向锁的取消:

    偏向锁是默认开启的,而且开始时间一般是比应用程序启动慢几秒,如果不想有这个延迟,那么可以使用-XX:BiasedLockingStartUpDelay=0;

    如果不想要偏向锁,那么可以通过-XX:-UseBiasedLocking = false来设置;

    1. 为什么要引入轻量级锁?

    轻量级锁考虑的是竞争锁对象的线程不多,而且线程持有锁的时间也不长的情景。因为阻塞线程需要CPU从用户态转到内核态,代价较大,如果刚刚阻塞不久这个锁就被释放了,那这个代价就有点得不偿失了,因此这个时候就干脆不阻塞这个线程,让它自旋这等待锁释放。

    1. 轻量级锁什么时候升级为重量级锁?

    线程1获取轻量级锁时会先把锁对象的对象头MarkWord复制一份到线程1的栈帧中创建的用于存储锁记录的空间(称为DisplacedMarkWord),然后使用CAS把对象头中的内容替换为线程1存储的锁记录(DisplacedMarkWord)的地址;

    如果在线程1复制对象头的同时(在线程1CAS之前),线程2也准备获取锁,复制了对象头到线程2的锁记录空间中,但是在线程2CAS的时候,发现线程1已经把对象头换了,线程2的CAS失败,那么线程2就尝试使用自旋锁来等待线程1释放锁。

    但是如果自旋的时间太长也不行,因为自旋是要消耗CPU的,因此自旋的次数是有限制的,比如10次或者100次,如果自旋次数到了线程1还没有释放锁,或者线程1还在执行,线程2还在自旋等待,这时又有一个线程3过来竞争这个锁对象,那么这个时候轻量级锁就会膨胀为重量级锁。重量级锁把除了拥有锁的线程都阻塞,防止CPU空转。

    注意:为了避免无用的自旋,轻量级锁一旦膨胀为重量级锁就不会再降级为轻量级锁了;偏向锁升级为轻量级锁也不能再降级为偏向锁。一句话就是 锁可以升级不可以降级,但是偏向锁状态可以被重置为无锁状态。

    在这里插入图片描述

    二、锁粗化

    通常情况下,为了保证多线程间的有效并发,会要求每个线程持有锁的时间尽可能短,但是大某些情况下,一个程序对同一个锁不间断、高频地请求、同步与释放,会消耗掉一定的系统资源,因为锁的讲求、同步与释放本身会带来性能损耗,这样高频的锁请求就反而不利于系统性能的优化了,虽然单次同步操作的时间可能很短。锁粗化就是告诉我们任何事情都有个度,有些情况下我们反而希望把很多次锁的请求合并成一个请求,以降低短时间内大量锁请求、同步、释放带来的性能损耗。

    public void doSomethingMethod(){
        synchronized(lock){
            //do some thing
        }
        //这是还有一些代码,做其它不需要同步的工作,但能很快执行完毕
        synchronized(lock){
            //do other thing
        }
    }
    

    上面的代码是有两块需要同步操作的,但在这两块需要同步操作的代码之间,需要做一些其它的工作,而这些工作只会花费很少的时间,那么我们就可以把这些工作代码放入锁内,将两个同步代码块合并成一个,以降低多次锁请求、同步、释放带来的系统性能消耗,合并后的代码如下:

    public void doSomethingMethod(){
        //进行锁粗化:整合成一次锁请求、同步、释放
        synchronized(lock){
            //do some thing
            //做其它不需要同步但能很快执行完的工作
            //do other thing
        }
    }
    

    注意:这样做是有前提的,就是中间不需要同步的代码能够很快速地完成,如果不需要同步的代码需要花很长时间,就会导致同步块的执行需要花费很长的时间,这样做也就不合理了。

    另一种需要锁粗化的极端的情况是:

    for(int i=0;i<size;i++){
        synchronized(lock){
        }
    }
    

    上面代码每次循环都会进行锁的请求、同步与释放,看起来貌似没什么问题,且在jdk内部会对这类代码锁的请求做一些优化,但是还不如把加锁代码写在循环体的外面,这样一次锁的请求就可以达到我们的要求,除非有特殊的需要:循环需要花很长时间,但其它线程等不起,要给它们执行的机会。

    锁粗化后的代码如下:

    synchronized(lock){
        for(int i=0;i<size;i++){
        }
    }
    

    三、锁消除

    锁消除是发生在编译器级别的一种锁优化方式。
    有时候我们写的代码完全不需要加锁,却执行了加锁操作。

    比如,StringBuffer类的append操作:

    @Override
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }
    

    从源码中可以看出,append方法用了synchronized关键词,它是线程安全的。但我们可能仅在线程内部把StringBuffer当作局部变量使用:

    package com.leeib.thread;
    public class Demo {
        public static void main(String[] args) {
            long start = System.currentTimeMillis();
            int size = 10000;
            for (int i = 0; i < size; i++) {
                createStringBuffer("Hyes", "为分享技术而生");
            }
            long timeCost = System.currentTimeMillis() - start;
            System.out.println("createStringBuffer:" + timeCost + " ms");
        }
        public static String createStringBuffer(String str1, String str2) {
            StringBuffer sBuf = new StringBuffer();
            sBuf.append(str1);// append方法是同步操作
            sBuf.append(str2);
            return sBuf.toString();
        }
    }
    

    代码中createStringBuffer方法中的局部对象sBuf,就只在该方法内的作用域有效,不同线程同时调用createStringBuffer()方法时,都会创建不同的sBuf对象,因此此时的append操作若是使用同步操作,就是白白浪费的系统资源。

    这时我们可以通过编译器将其优化,将锁消除,前提是java必须运行在server模式(server模式会比client模式作更多的优化),同时必须开启逃逸分析:

    -server -XX:+DoEscapeAnalysis -XX:+EliminateLocks

    其中+DoEscapeAnalysis表示开启逃逸分析,+EliminateLocks表示锁消除

    逃逸分析:比如上面的代码,它要看sBuf是否可能逃出它的作用域?如果将sBuf作为方法的返回值进行返回,那么它在方法外部可能被当作一个全局对象使用,就有可能发生线程安全问题,这时就可以说sBuf这个对象发生逃逸了,因而不应将append操作的锁消除,但我们上面的代码没有发生锁逃逸,锁消除就可以带来一定的性能提升。

    展开全文
  • 隐式(内置) - synchronized的使用方法: 1.synchronized 加在方法上面,是加在当前类的对象上面,this。 2.synchronized 加在静态方法上面,加在当前方法所在类的上面Test.class. 3.synchron
  • Java对象的锁升级过程 在JDK1.7版本之后,对Sunchronized关键字进行了优化,如果对对象进行Synchronized进行加锁,那么针对资源的竞争情况不同,锁会有一个升级的过程,以保证资源是最佳的利用状况。 过程可以概括为...
  • Java synchronized锁升级过程简述(面试可用)

    千次阅读 热门讨论 2021-04-30 09:45:53
    java 锁升级流程 Synchronized 的锁升级流程是这样:无锁 ----> 偏向锁 ----> 轻量级 锁 ----> 锁自旋 ----> 重量级锁 偏向锁 偏向锁,简单的讲,就是在锁对象的对象头中有个ThreaddId字段,这个...
  • Java锁升级过程

    2022-04-01 10:44:28
    的四种状态:无锁、偏向、轻量级、重量级(级别从高到低) ...会在Java对象头和栈帧中记录偏向的threadID,因为偏向不会主动释放,因此以后线程1再次获取的时候,需要比较当前线程的threadID和Ja
  • JDK1.6的优化 曾经遇到多线程加锁操作都是直接用synchronized,但在jdk1.6前,synchronized是重量级,随着jdk1.6对synchronized进行的各种优化后,synchronized并不会显得那么重 如: 偏向:偏向某一个线程...
  • java synchronized锁升级过程

    万次阅读 2020-06-10 17:38:31
    锁升级过程是怎样的呢? 主要一开始是无锁的状态,如果偏向锁未启动,当有其他线程竞争时,会升级为轻量级锁,如果偏向锁启动,则会升级为偏向锁,如果竞争激烈则会从偏向锁升级为重量级锁,如果不激烈则有偏向...
  • 文章目录前言一、基础知识1、内核态&用户态1、池2、等待池二、偏向二、自旋二、重量级1.引入库2.读入数据总结 前言 Java中的如果想实现线程安全,就不得不提一个关键字 ...可以升级,但不能降级,
  • Java中锁的四种状态以及锁升级过程

    千次阅读 2020-11-11 23:11:10
    Java(1.6+)中的状态一共有四种,级别由低到高分别是:无锁、偏向、轻量级、重量级,这几个状态会随着竞争情况逐渐升级,其中可以升级,但是不能降级。Java中加的最简单方式就是加synchronized关键字...
  • Java锁升级

    千次阅读 多人点赞 2020-04-06 01:36:52
    Java锁升级 对象内存布局 Java对象在内存中存储的布局可以分为3块区域: 对象头、实例数据、对齐填充。 对象头,分为两个部分,第一个部分存储对象自身的运行时数据,又称为Mark Word,32位虚拟机占32bit,64位虚拟机占...
  • 什么是偏向?什么是轻量级?什么是重量级?哪些叫,但不是真正的
  • java并发之升级

    万次阅读 2018-06-19 19:49:34
    说明:本文大部分内容来自《并发编程的艺术》,再加上自己网络整理和理解 以下内容来自《java并发编程的艺术》作者:方鹏飞 魏鹏 程晓明 ...升级与对比 Java SE 1.6为了减少获得和释放...
  • Java中的锁升级

    2022-03-15 09:07:17
    关于锁升级的四种级别,即如何升级
  • java高并发开发必须要会的知识,锁知识,关键字 Synchronized_锁升级知识点总结,面试常用
  • 主要记录对象的状态 class pointer 指向对象字节码的指针 instance data 实例数据 padding jvm设计时对象所占大小要被8整除,要是位数不够需要加padding 2、对象布局的查看 使用JOL类可以查看对象的内存...
  • synchronized 锁升级过程

    千次阅读 2021-10-28 22:29:14
    synchronized 锁升级过程就是其优化的核心:偏向锁 -> 轻量级锁 -> 重量级锁 class Test{ private static final Object object = new Object(); public void test(){ synchronized(object) { // do ...
  • 1.概述 Java内置锁的状态总共有4种状态,级别由低到高依次为:无锁、偏向锁、轻...并且4种状态会随着竞争的情况逐渐升级,而且是不可逆的过程,即不可降级,也就是说只能进行锁升级(从低级别到高级别) 2.锁升级演变
  • synchronized锁升级过程

    千次阅读 2022-03-13 18:30:10
    从理论到实操,详细介绍了的底层升级过程并用代码进行验证,加深记忆
  • Synchronized锁升级过程

    千次阅读 2021-08-02 01:02:04
    一、Synchronized的锁升级过程 高效并发是从JDK 5到JDK 6的一个重要改进,HotSpot虛拟机开发团队在这个版本上花费了大量的精力去实现各种锁优化技术, 包括偏向锁( Biased Locking )、轻量级锁( Lightweight ...
  • java 中的----的基础和升级过程

    千次阅读 2020-07-10 17:24:02
    java 中的----的基础和升级过程 的类型 从宏观上分类,分为悲观与乐观。 乐观:顾名思义,就是一个很乐观的,他就认为你一直不会上,直到用的时候,判断一下你会不会上。即认为读多写少,遇到...
  • Java锁机制--锁概述 锁升级

    千次阅读 2020-09-12 18:40:34
    Java锁原理 在探究Java锁原理之前我们需要知道一些基础知识,方便对锁的理解: synchronized关键字 CAS Java对象内存模型 CAS CAS概述 CAS(Compare And Swap)比较和替换 定义一个int类型的变量a,初始值为0。 ...
  • 锁升级过程(偏向锁/轻量级锁/重量级锁)

    千次阅读 多人点赞 2021-04-09 13:00:09
    如果想要透彻的理解java锁的来龙去脉,需要先了解锁的基础知识:锁的类型、java线程阻塞的代价、Markword。 锁的类型 锁从宏观上分类,分为悲观锁与乐观锁。 乐观锁 乐观锁是一种乐观思想,即认为读多写少,遇到并发...
  • 锁升级过程

    千次阅读 多人点赞 2021-08-25 19:47:05
    1.说到锁升级过程,我们就得说一下对象头 对象头 java对象保存在内存中,由3个部分组成: 1. 对象头 2. 实例数据 3. 对齐填充字节 4. 如果是数组还包含数组长度 对象头的存在形式 ...
  • java synchronized 锁升级

    千次阅读 2021-06-13 10:50:29
    在JDK1.6之后,synchronized引入了无锁、偏向、轻量、重量的不可逆状态升级过程,以提高的获取和释放效率。 四种状态对象的对象头以及升级过程 最开始对象处于无锁状态,当初次执行到synchronized代码...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 51,993
精华内容 20,797
关键字:

java 锁升级的过程

java 订阅