精华内容
下载资源
问答
  • Java 偏向锁

    2018-07-15 17:43:14
    Java偏向锁(Biased Locking)是Java6引入的一项多线程优化。它通过消除资源无竞争情况下的同步原语,进一步提高了程序的运行性能。 偏向锁,顾名思义,它会偏向于第一个访问锁的线程,如果在接下来的运行过程中,该...

    Java偏向锁(Biased Locking)是Java6引入的一项多线程优化。它通过消除资源无竞争情况下的同步原语,进一步提高了程序的运行性能。
    偏向锁,顾名思义,它会偏向于第一个访问锁的线程,如果在接下来的运行过程中,该锁没有被其他的线程访问,则持有偏向锁的线程将永远不需要触发同步。
    如果在运行过程中,遇到了其他线程抢占锁,则持有偏向锁的线程会被挂起,JVM会尝试消除它身上的偏向锁,将锁恢复到标准的轻量级锁。(偏向锁只能在单线程下起作用)

    锁存在Java对象头里。如果对象是数组类型,则虚拟机用3个Word(字宽)存储对象头,如果对象是非数组类型,则用2字宽存储对象头。在32位虚拟机中,一字宽等于四字节,即32bit。
    机制:每个锁都关联一个请求计数器和一个占有他的线程,当请求计数器为0时,这个锁可以被认为是unhled的,当一个线程请求一个unheld的锁时,JVM记录锁的拥有者,并把锁的请求计数加1,如果同一个线程再次请求这个锁时,请求计数器就会增加,当该线程退出syncronized块时,计数器减1,当计数器为0时,锁被释放(这就保证了锁是可重入的,不会发生死锁的情况)。

    偏向锁,简单的讲,就是在锁对象的对象头中有个ThreaddId字段,这个字段如果是空的,第一次获取锁的时候,就将自身的ThreadId写入到锁的ThreadId字段内,将锁头内的是否偏向锁的状态位置1.这样下次获取锁的时候,直接检查ThreadId是否和自身线程Id一致, 如果一致,则认为当前线程已经获取了锁,因此不需再次获取锁,略过了轻量级锁和重量级锁的加锁阶段。提高了效率。
    但是偏向锁也有一个问题,就是当锁有竞争关系的时候,需要解除偏向锁,使锁进入竞争的状态。

    偏向锁的释放之后会进入到轻量级锁阶段,两个线程进入锁竞争状态,一个具体例子可以参考synchronized锁机制。
    synchronized锁流程如下:
    第一步,检查MarkWord里面是不是放的自己的ThreadId ,如果是,表示当前线程是处于 “偏向锁”
    第二步,如果MarkWord不是自己的ThreadId,锁升级,这时候,用CAS来执行切换,新的线程根据MarkWord里面现有的ThreadId,通知之前线程暂停,之前线程将Markword的内容置为空。
    第三步,两个线程都把对象的HashCode复制到自己新建的用于存储锁的记录空间,接着开始通过CAS操作,把共享对象的MarKword的内容修改为自己新建的记录空间的地址的方式竞争MarkWord,
    第四步,第三步中成功执行CAS的获得资源,失败的则进入自旋
    第五步,自旋的线程在自旋过程中,成功获得资源(即之前获的资源的线程执行完成并释放了共享资源),则整个状态依然处于 轻量级锁的状态,如果自旋失败
    第六步,进入重量级锁的状态,这个时候,自旋的线程进行阻塞,等待之前线程执行完成并唤醒自己

    因此 流程是这样的 偏向锁->轻量级锁->重量级锁(由这三个关键词串联起来的过程才是最重要的)

    总结:
    偏向锁,其实是无锁竞争下可重入锁的简单实现

    参考:
    http://blog.163.com/silver9886@126/blog/static/35971862201472274958280/
    http://xly1981.iteye.com/blog/1766224

    展开全文
  • java 偏向锁

    千次阅读 2016-05-08 19:05:57
    Java偏向锁(Biased Locking)是Java6引入的一项多线程优化。它通过消除资源无竞争情况下的同步原语,进一步提高了程序的运行性能。 偏向锁,顾名思义,它会偏向于第一个访问锁的线程,如果在接下来的运行过程中,该...

    java 偏向锁  

    Java偏向锁(Biased Locking)是Java6引入的一项多线程优化。它通过消除资源无竞争情况下的同步原语,进一步提高了程序的运行性能。

    偏向锁,顾名思义,它会偏向于第一个访问锁的线程,如果在接下来的运行过程中,该锁没有被其他的线程访问,则持有偏向锁的线程将永远不需要触发同步。

    如果在运行过程中,遇到了其他线程抢占锁,则持有偏向锁的线程会被挂起,JVM会尝试消除它身上的偏向锁,将锁恢复到标准的轻量级锁。(偏向锁只能在单线程下起作用)

    因此 流程是这样的 偏向锁->轻量级锁->重量级锁


    锁存在Java对象头里。如果对象是数组类型,则虚拟机用3个Word(字宽)存储对象头,如果对象是非数组类型,则用2字宽存储对象头。在32位虚拟机中,一字宽等于四字节,即32bit。

    机制:每个锁都关联一个请求计数器和一个占有他的线程,当请求计数器为0时,这个锁可以被认为是unhled的,当一个线程请求一个unheld的锁时,JVM记录锁的拥有者,并把锁的请求计数加1,如果同一个线程再次请求这个锁时,请求计数器就会增加,当该线程退出syncronized块时,计数器减1,当计数器为0时,锁被释放(这就保证了锁是可重入的,不会发生死锁的情况)。


    偏向锁,简单的讲,就是在锁对象的对象头中有个ThreaddId字段,这个字段如果是空的,第一次获取锁的时候,就将自身的ThreadId写入到锁的ThreadId字段内,将锁头内的是否偏向锁的状态位置1.这样下次获取锁的时候,直接检查ThreadId是否和自身线程Id一致,如果一致,则认为当前线程已经获取了锁,因此不需再次获取锁,略过了轻量级锁和重量级锁的加锁阶段。提高了效率。

    但是偏向锁也有一个问题,就是当锁有竞争关系的时候,需要解除偏向锁,使锁进入竞争的状态。

    具体图片如下:


    偏向锁的抢占,其实就是两个进程对锁的抢占,在synchrnized锁下表现为轻量锁方式进行抢占。


     

     注意这时只是偏向锁的释放,之后会进入到轻量级锁阶段,两个线程进入锁竞争状态,一个具体例子可以参考synchronized锁机制。

    注:synchronized锁流程如下(转自http://xly1981.iteye.com/blog/1766224):

    第一步,检查MarkWord里面是不是放的自己的ThreadId ,如果是,表示当前线程是处于 “偏向锁” 

    第二步,如果MarkWord不是自己的ThreadId,锁升级,这时候,用CAS来执行切换,新的线程根据MarkWord里面现有的ThreadId,通知之前线程暂停,之前线程将Markword的内容置为空。 

    第三步,两个线程都把对象的HashCode复制到自己新建的用于存储锁的记录空间,接着开始通过CAS操作,把共享对象的MarKword的内容修改为自己新建的记录空间的地址的方式竞争MarkWord, 

    第四步,第三步中成功执行CAS的获得资源,失败的则进入自旋 

    第五步,自旋的线程在自旋过程中,成功获得资源(即之前获的资源的线程执行完成并释放了共享资源),则整个状态依然处于 轻量级锁的状态,如果自旋失败 

    第六步,进入重量级锁的状态,这个时候,自旋的线程进行阻塞,等待之前线程执行完成并唤醒自己

     

    总结:

    偏向锁,其实是无锁竞争下可重入锁的简单实现

    展开全文
  • Java偏向锁

    千次阅读 2015-06-05 14:07:45
    概述偏向锁是JDK 1.6提出的一种锁优化方式,起核心思想是如果程序没有竞争,则取消之前已经取得锁的线程的同步操作。也就是说,某一个锁被一个线程获取之后,便进入了偏向锁模式,当该线程再次请求这个锁时,就无需...

    概述

    偏向锁是JDK 1.6提出的一种锁优化方式,起核心思想是如果程序没有竞争,则取消之前已经取得锁的线程的同步操作。也就是说,某一个锁被一个线程获取之后,便进入了偏向锁模式,当该线程再次请求这个锁时,就无需再进行相关的同步操作,从而节省了操作时间。但是如果在此期间,有其他线程申请了这个锁,则退出偏向锁模式。在JVM中可以使用-XX:+UseBiasedLocking设置启用偏向锁。

    实验

    看如下的代码:

    package com.winwill.lock;
    
    import java.util.List;
    import java.util.Vector;
    
    /**
     * @author qifuguang
     * @date 15/6/5 13:44
     */
    public class TestBiasedLock {
        private static List<Integer> list = new Vector<Integer>();
    
        public static void main(String[] args) {
            long tsStart = System.currentTimeMillis();
            for (int i = 0; i < 10000000; i++) {
                list.add(i);
            }
            System.out.println("一共耗费:" + (System.currentTimeMillis() - tsStart) + " ms");
        }
    }
    

    代码中使用一个循环一直往Vector中新增元素,Vector的add操作会请求锁:

        /**
         * Appends the specified element to the end of this Vector.
         *
         * @param e element to be appended to this Vector
         * @return {@code true} (as specified by {@link Collection#add})
         * @since 1.2
         */
        public synchronized boolean add(E e) {
            modCount++;
            ensureCapacityHelper(elementCount + 1);
            elementData[elementCount++] = e;
            return true;
        }

    我们使用如下的参数运行代码:

    -XX:+UseBiasedLocking
    -XX:BiasedLockingStartupDelay=0
    -Xmx512m
    -Xms512m

    -XX:BiasedLockingStartupDelay=0这个参数表示虚拟机一启动就启动偏向锁模式,因为默认情况下,虚拟机启动4s之后才会启动偏向锁模式,该例运行时间较短,故做此设置。

    得到如下结果:
    这里写图片描述

    但是,如果我们使用如下的参数运行程序:

    -XX:-UseBiasedLocking
    -Xmx512m
    -Xms512m

    得到的结果如下:
    这里写图片描述

    结论

    偏向锁在少竞争的情况下,对系统性能有一定的帮助。

    注意事项

    偏向锁在竞争激烈的情况下没有太强的优化效果,因为大量的竞争会导致持有锁的线程不停地切换,锁也很难一直保持偏向模式,此时,使用偏向锁不仅不能优化程序,反而有可能降低程序性能。因为,在竞争激烈的场景下可以使用-XX:-UseBiasedLocking参数禁用偏向锁。

    展开全文
  • 今天简单了解了一下java轻量级锁和重量级锁以及偏向锁。看了看这篇文章觉得写的不错 原文链接 java 偏向锁、轻量级锁及重量级锁synchronized原理 Java对象头与Monitor java对象头是实现synchronized的锁对象的基础,...

    今天简单了解了一下java轻量级锁和重量级锁以及偏向锁。看了看这篇文章觉得写的不错
    原文链接

    java 偏向锁、轻量级锁及重量级锁synchronized原理

    Java对象头与Monitor

    java对象头是实现synchronized的锁对象的基础,synchronized使用的锁对象是存储在Java对象头里的。

    对象头包含两部分:Mark Word 和 Class Metadata Address

    在这里插入图片描述

    其中Mark Word在默认情况下存储着对象的HashCode、分代年龄、锁标记位等以下是32位JVM的Mark Word默认存储结构

    在这里插入图片描述

    由于对象头的信息是与对象自身定义的数据没有关系的额外存储成本,因此考虑到JVM的空间效率,Mark Word 被设计成为一个非固定的数据结构,以便存储更多有效的数据,它会根据对象本身的状态复用自己的存储空间,如32位JVM下,除了上述列出的Mark Word默认存储结构外,还有如下可能变化的结构:

    在这里插入图片描述

    重量级锁synchronized的实现
    重量级锁也就是通常说synchronized的对象锁,锁标识位为10,其中指针指向的是monitor对象(也称为管程或监视器锁)的起始地址。每个对象都存在着一个 monitor 与之关联,对象与其 monitor 之间的关系有存在多种实现方式,如monitor可以与对象一起创建销毁或当线程试图获取对象锁时自动生成,但当一个 monitor 被某个线程持有后,它便处于锁定状态。

    在这里插入图片描述

    上图简单描述多线程获取锁的过程,当多个线程同时访问一段同步代码时,首先会进入 Entry Set当线程获取到对象的monitor 后进入 The Owner 区域并把monitor中的owner变量设置为当前线程,同时monitor中的计数器count加1,若线程调用 wait() 方法,将释放当前持有的monitor,owner变量恢复为null,count自减1,同时该线程进入 WaitSet集合中等待被唤醒。若当前线程执行完毕也将释放monitor(锁)并复位变量的值,以便其他线程进入获取monitor(锁)。

    由此看来,monitor对象存在于每个Java对象的对象头中(存储的指针的指向),synchronized锁便是通过这种方式获取锁的,也是为什么Java中任意对象可以作为锁的原因,同时也是notify/notifyAll/wait等方法存在于顶级对象Object中的原因。

    自旋锁与自适应自旋
    Java的线程是映射到操作系统的原生线程之上的,如果要阻塞或唤醒一个线程,都需要操作系统来帮忙完成,这就需要从用户态转换到核心态中,因此状态转换需要耗费很多的处理器时间,对于代码简单的同步块(如被synchronized修饰的getter()和setter()方法),状态转换消耗的时间有可能比用户代码执行的时间还要长。

    虚拟机的开发团队注意到在许多应用上,共享数据的锁定状态只会持续很短的一段时间,为了这段时间去挂起和恢复线程并不值得。如果物理机器有一个以上的处理器,能让两个或以上的线程同时并行执行,我们就可以让后面请求锁的那个线程“稍等一下“,但不放弃处理器的执行时间,看看持有锁的线程是否很快就会释放锁。为了让线程等待,我们只需让线程执行一个忙循环(自旋),这项技术就是所谓的自旋锁。

    自旋锁在JDK1.4.2中引入,使用-XX:+UseSpinning来开启。JDK1.6中已经变为默认开。自旋等待不能代替阻塞。自旋等待本身虽然避免了线程切换的开销,但它是要占用处理器时间的,因此,如果锁被占用的时间很短,自旋等待的效果就会非常好,反之,如果锁被占用的时间很长,那么自旋的线程只会浪费处理器资源。因此,自旋等待的时间必须要有一定的限度,如果自旋超过了限定次数(默认是10次,可以使用-XX:PreBlockSpin来更改)没有成功获得锁,就应当使用传统的方式去挂起线程了。

    JDK1.6中引入自适应的自旋锁,自适应意味着自旋的时间不在固定。而是有虚拟机对程序锁的监控与预测来设置自旋的次数。

    自旋是在轻量级锁中使用的

    轻量级锁
    轻量级锁提升程序同步性能的依据是:对于绝大部分的锁,在整个同步周期内都是不存在竞争的(区别于偏向锁)。这是一个经验数据。如果没有竞争,轻量级锁使用CAS操作避免了使用互斥量的开销,但如果存在锁竞争,除了互斥量的开销外,还额外发生了CAS操作,因此在有竞争的情况下,轻量级锁比传统的重量级锁更慢。

    轻量级锁的加锁过程:
    在代码进入同步块的时候,如果同步对象锁状态为无锁状态(锁标志位为“01”状态,是否为偏向锁为“0”),虚拟机首先将在当前线程的栈帧中建立一个名为锁记录(Lock Record)的空间,用于存储锁对象目前的Mark Word的拷贝,官方称之为 Displaced Mark Word。这时候线程堆栈与对象头的状态如图:

    在这里插入图片描述

    拷贝对象头中的Mark Word复制到锁记录(Lock Record)中;

    拷贝成功后,虚拟机将使用CAS操作尝试将锁对象的Mark Word更新为指向Lock Record的指针,并将线程栈帧中的Lock Record里的owner指针指向Object的 Mark Word。
    如果这个更新动作成功了,那么这个线程就拥有了该对象的锁,并且对象Mark Word的锁标志位设置为“00”,即表示此对象处于轻量级锁定状态,这时候线程堆栈与对象头的状态如图所示。
    在这里插入图片描述

    如果这个更新操作失败了,虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧,如果是就说明当前线程已经拥有了这个对象的锁,那就可以直接进入同步块继续执行。否则说明多个线程竞争锁,轻量级锁就要膨胀为重量级锁,锁标志的状态值变为“10”,Mark Word中存储的就是指向重量级锁(互斥量)的指针,后面等待锁的线程也要进入阻塞状态。

    在这里插入图片描述

    偏向锁
    偏向锁是JDK6中引入的一项锁优化,它的目的是消除数据在无竞争情况下的同步原语,进一步提高程序的运行性能。

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

    当锁对象第一次被线程获取的时候,线程使用CAS操作把这个线程的ID记录在对象Mark Word之中,同时置偏向标志位1。以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁,只需要简单地测试一下对象头的Mark Word里是否存储着指向当前线程的ID。如果测试成功,表示线程已经获得了锁。

    当有另外一个线程去尝试获取这个锁时,偏向模式就宣告结束。根据锁对象目前是否处于被锁定的状态,撤销偏向后恢复到未锁定或轻量级锁定状态。
    在这里插入图片描述

    偏向所锁,轻量级锁及重量级锁
    偏向所锁,轻量级锁都是乐观锁,重量级锁是悲观锁。
    一个对象刚开始实例化的时候,没有任何线程来访问它的时候。它是可偏向的,意味着,它现在认为只可能有一个线程来访问它,所以当第一个
    线程来访问它的时候,它会偏向这个线程,此时,对象持有偏向锁。偏向第一个线程,这个线程在修改对象头成为偏向锁的时候使用CAS操作,并将
    对象头中的ThreadID改成自己的ID,之后再次访问这个对象时,只需要对比ID,不需要再使用CAS在进行操作。
    一旦有第二个线程访问这个对象,因为偏向锁不会主动释放,所以第二个线程可以看到对象时偏向状态,这时表明在这个对象上已经存在竞争了,检查原来持有该对象锁的线程是否依然存活,如果挂了,则可以将对象变为无锁状态,然后重新偏向新的线程,如果原来的线程依然存活,则马上执行那个线程的操作栈,检查该对象的使用情况,如果仍然需要持有偏向锁,则偏向锁升级为轻量级锁,(偏向锁就是这个时候升级为轻量级锁的)。如果不存在使用了,则可以将对象回复成无锁状态,然后重新偏向。
    轻量级锁认为竞争存在,但是竞争的程度很轻,一般两个线程对于同一个锁的操作都会错开,或者说稍微等待一下(自旋),另一个线程就会释放锁。 但是当自旋超过一定的次数,或者一个线程在持有锁,一个在自旋,又有第三个来访时,轻量级锁膨胀为重量级锁,重量级锁使除了拥有锁的线程以外的线程都阻塞,防止CPU空转。

    展开全文
  • Java 偏向锁的升级

    2020-09-11 11:14:46
    jvm源码(biasedLocking.cpp)解析的偏向锁升级流程(忽略一些细节)。 示例中:线程1当前拥有偏向锁对象,线程2是需要竞争到偏向锁。 线程2来竞争锁对象; 判断当前对象头是否是偏向锁; 判断拥有偏向锁的线程1是否还...
  • 阅读本文的读者,需要对Java轻量级锁有...Java偏向锁(Biased Locking)是Java6引入的一项多线程优化。它通过消除资源无竞争情况下的同步原语,进一步提高了程序的运行性能。 轻量级锁也是一种多线程优化,它与偏向锁
  • java 偏向锁优化技术

    千次阅读 2017-03-07 10:26:31
    如果在运行过程中,遇到了其他线程抢占该锁,则持有偏向锁的线程会被挂起,JVM会尝试消除它身上的偏向锁,将锁恢复到标准的轻量级锁。2.消除偏向锁如果一个锁只被单线程用到, 那么偏向锁的优化是有意义的. 如果自己...
  • 转载——java 中的锁 – 偏向锁、轻量级锁、自旋锁、重量级锁
  • Java偏向锁和轻量级锁

    2018-06-30 15:32:29
    Java SE 1.6对锁进行了大量优化工作,引入轻量级锁和偏向锁,这里只对这两种优化作说明。Java SE 1.6中的锁状态分为无锁、偏向锁、轻量锁、重量锁4种,级别依次递增,性能越来越差,且升级后不允许降级,这么做能在...
  • 获取偏向锁:线程1进入同步,在锁的对象的对象头(理解成对象的信息表)有个是否是偏向锁,以及偏向的线程id。如果偏向的线程id不是自己,线程1就用CAS操作替换成自己,成功就获取到锁了,退出同步块的时候
  • 检测Mark Word里面是不是当前线程的ID,如果是,表示当前线程处于偏向锁 2. 如果不是,则使用CAS将当前线程的ID替换Mard Word,如果成功则表示当前线程获得偏向锁,置偏向标志位1 3. 如果失败,则说明发生竞争,...
  • 因为偏向锁,锁住对象时,会写入对象头相应的标识,我们先把对象头(官方叫法为:Mark Word)的图示如下(借用了网友的图片): 通过上面的图片,我们可以知道,对象处于偏向锁时,mark word中的偏向锁标记为1,...
  • 1 前言 在Java SE1.6之前,synchronized一直都是重量级锁,如果某个...在Java SE1.6之后,为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁,以及锁的存储结构和升级过程。这些锁就存在锁对象的对象...
  • 前言:java的线程是映射到操作系统的原生线程上的,如果要阻塞和唤醒线程,需要操作系统帮忙,要从用户态转为核心态,需要花费很多处理器时间。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,514
精华内容 1,005
关键字:

java偏向锁

java 订阅