>>交流分享Java编程技术,对《Java面向对象编程》等书籍提供技术支持 书籍支持  视频课程  卫琴专栏  在线测试  资源下载  联系我们
发表一个新主题 开启一个新投票 回复文章 您是本文章第 11777 个阅读者 刷新本主题
 * 贴子主题:  深入分析synchronized实现原理 回复文章 点赞(0)  收藏  
作者:flybird    发表时间:2020-02-06 14:05:29     消息  查看  搜索  好友  邮件  复制  引用

                                            
在Java中synchronized关键字最主要有以下3种应用方式

     修饰实例方法,作用于当前实例加锁,进入同步代码前要获得当前实例的锁

     修饰静态方法,作用于当前类对象加锁,进入同步代码前要获得当前类对象的锁

     修饰代码块,指定加锁对象,对给定对象加锁,进入同步代码库前要获得给定对象的锁。

synchronized和ReentrantLock区别

  1.  可重入性


字面的意思就是可以再次进入的锁,synchronized其实也是可重锁,同一线程每进入一次,锁的计数器都会加一,在释放锁是计数器都会减一,只有当计数器为0 时才能释放锁。

      2 .  锁的实现


ReentrantLock是JDK实现的  Synchronized 是JVM实现

前者可以直接看到源码,后者实现难以看到。

      3. 性能的区别


在Synchronized优化以前,synchronized的性能是比ReenTrantLock差很多的,但是自从Synchronized引入了偏向锁,轻量级锁(自旋锁)后,两者的性能就差不多了,在两种方法都可用的情况下,官方甚至建议使用synchronized,其实synchronized的优化我感觉就借鉴了ReenTrantLock中的CAS技术。都是试图在用户态就把加锁问题解决,避免进入内核态的线程阻塞。

      4. 功能的区别


便利性:很明显Synchronized的使用比较方便简洁,并且由编译器去保证锁的加锁和释放,而ReenTrantLock需要手工声明来加锁和释放锁,为了避免忘记手工释放锁造成死锁,所以最好在finally中声明释放锁。

锁的细粒度和灵活度:很明显ReenTrantLock优于Synchronized

     当你需要时候一下三种功能是需要使用ReentrantLock
  1. ReentranLock 可以指定公平锁还是非公平锁

    (公共锁就是先等待的线程先获得锁)

    实现自旋锁,通过循环调用CAS操作来实现加锁,性能比较好,避免进入内核态的线程阻塞。
  2. 提供了Condition类,可以分组唤醒需要唤醒的线程
  3. 提供能够中断等待锁的线程的机制,lock.lockInterruptibly()
具体使用场景要根据实际的业务进行分析

使用Synchronized时不需要释放锁,jvm会帮助我们做释放锁的操作

     ReentrantLock的构造函数,默认为false 非公平锁,可以传入true,设置为公平锁,但是性能会变差。    

     public ReentrantLock() {
        sync = new NonfairSync();
    }
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

@Slf4j
@ThreadSafe
public class LockExample2 {

    // 请求总数
    public static int clientTotal = 5000;

    // 同时并发执行的线程数
    public static int threadTotal = 200;

    public static int count = 0;

    private final static Lock lock = new ReentrantLock(false);

    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal ; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception", e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}", count);
    }

    private static void add() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

synchronized实现

synchronized底层语义原理

Java 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现, 无论是显式同步(有明确的 monitorenter 和 monitorexit 指令,即同步代码块)还是隐式同步都是如此。在 Java 语言中,同步用的最多的地方可能是被 synchronized 修饰的同步方法。同步方法 并不是由 monitorenter 和 monitorexit 指令来实现同步的,而是由方法调用指令读取运行时常量池中方法的 ACC_SYNCHRONIZED 标志来隐式实现的,关于这点,稍后详细分析。下面先来了解一个概念Java对象头,这对深入理解synchronized实现原理非常关键。

     理解Java对象头与Monitor

在JVM中,对象在内存中的布局分为三块区域:对象头、实例数据和对齐填充。

     实例变量:存放类的属性数据信息,包括父类的属性信息,如果是数组的实例部分还包括数组的长度,这部分内存按4字节对齐。

     填充数据:由于虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的,仅仅是为了字节对齐,这点了解即可。

     而对于顶部,则是Java头对象,它实现synchronized的锁对象的基础,这点我们重点分析它,一般而言,synchronized使用的锁对象是存储在Java对象头里的,jvm中采用2个字来存储对象头(如果对象是数组则会分配3个字,多出来的1个字记录的是数组长度),其主要结构是由Mark Word 和 Class Metadata Address 组成,其结构说明如下表:

    
虚拟机位数 头对象结构 说明
32/64bit Mark Word 存储对象的hashCode、锁信息或分代年龄或GC标志等信息
32/64bit Class Metadata Address 类型指针指向对象的类元数据,JVM通过这个指针确定该对象是哪个类的实例。

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

    
锁状态 25bit 4bit 1bit是否是偏向锁 2bit 锁标志位
无锁 对象的hashCode 分代年龄 0 01

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

点击在新窗口中浏览原图
CTRL+鼠标滚轮放大或缩小

     其中轻量级锁和偏向锁是Java 6 对 synchronized 锁进行优化后新增加的,稍后我们会简要分析。这里我们主要分析一下重量级锁也就是通常说synchronized的对象锁,锁标识位为10,其中指针指向的是monitor对象(也称为管程或监视器锁)的起始地址。每个对象都存在着一个 monitor 与之关联,对象与其 monitor 之间的关系有存在多种实现方式,如monitor可以与对象一起创建销毁或当线程试图获取对象锁时自动生成,但当一个 monitor 被某个线程持有后,它便处于锁定状态。在Java虚拟机(HotSpot)中,monitor是由ObjectMonitor实现的,其主要数据结构如下(位于HotSpot虚拟机源码ObjectMonitor.hpp文件,C++实现的)    

ObjectMonitor() {
    _header       = NULL;
    _count        = 0; //记录个数
    _waiters      = 0,
    _recursions   = 0;
    _object       = NULL;
    _owner        = NULL;
    _WaitSet      = NULL; //处于wait状态的线程,会被加入到_WaitSet
    _WaitSetLock  = 0 ;
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ;
    FreeNext      = NULL ;
    _EntryList    = NULL ; //处于等待锁block状态的线程,会被加入到该列表
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
  }

ObjectMonitor中有两个队列,_WaitSet 和 _EntryList,用来保存ObjectWaiter对象列表( 每个等待锁的线程都会被封装成ObjectWaiter对象),_owner指向持有ObjectMonitor对象的线程,当多个线程同时访问一段同步代码时,首先会进入 _EntryList 集合,当线程获取到对象的monitor 后进入 _Owner 区域并把monitor中的owner变量设置为当前线程同时monitor中的计数器count加1,若线程调用 wait() 方法,将释放当前持有的monitor,owner变量恢复为null,count自减1,同时该线程进入 WaitSe t集合中等待被唤醒。若当前线程执行完毕也将释放monitor(锁)并复位变量的值,以便其他线程进入获取monitor(锁)。如下图所示

     由此看来,monitor对象存在于每个Java对象的对象头中(存储的指针的指向),synchronized锁便是通过这种方式获取锁的,也是为什么Java中任意对象可以作为锁的原因,同时也是notify/notifyAll/wait等方法存在于顶级对象Object中的原因(关于这点稍后还会进行分析),ok~,有了上述知识基础后,下面我们将进一步分析synchronized在字节码层面的具体语义实现。    

public static void main(String[] args)
{
    synchronized (TestMain.class)
    {
        
    }
}        

public static void main(java.lang.String[]);
  flags: ACC_PUBLIC, ACC_STATIC
  Code:
    stack=2, locals=1, args_size=1
       0: ldc           #1                  // class com/xrq/test53/TestMain
       2: dup
       3: monitorenter
       4: monitorexit
       5: return
    LineNumberTable:
      line 7: 0
      line 11: 5
    LocalVariableTable:
      Start  Length  Slot  Name   Signature
             0       6     0  args   [Ljava/lang/String;

synchronizatied关键字在修饰方法和类时,字节码上略有不同,但是实现方式是基本相同的。

     在字节码中我们可以看到monitor关键字

在执行monitorenter指令时,首先要尝试获取对象的锁,如果这个对象没有被锁定,或者当前线程已经拥有了那个对象的锁,把锁的计数器加1,相应地,在执行monitorexit指令时会将锁计数器减1,当计数器为0时,锁就会被释放。如果获取对象锁失败,那当前线程就要阻塞等待,直到对象锁被另外一个线程释放为止。

关于monitorenter和monitorexit,有两点是要特别注意的:

     1、synchronized同步块对同一条线程来说是可重入的,不会出现把自己锁死的问题

     2、同步块在已进入的线程执行完之前,会阻塞后面其它线程的进入

     锁的状态总共有四种,无锁状态、偏向锁、轻量级锁和重量级锁。随着锁的竞争,锁可以从偏向锁升级到轻量级锁,再升级的重量级锁,但是锁的升级是单向的,也就是说只能从低到高升级,不会出现锁的降级,关于重量级锁,前面我们已详细分析过,下面我们将介绍偏向锁和轻量级锁以及JVM的其他优化手段,这里并不打算深入到每个锁的实现和转换过程更多地是阐述Java虚拟机所提供的每个锁的核心优化思想,毕竟涉及到具体过程比较繁琐,如需了解详细过程可以查阅《深入理解Java虚拟机原理》。

偏向锁

偏向锁是Java 6之后加入的新锁,它是一种针对加锁操作的优化手段,经过研究发现,在大多数情况下,锁不仅不存在多线程竞争,而且总是由同一线程多次获得,因此为了减少同一线程获取锁(会涉及到一些CAS操作,耗时)的代价而引入偏向锁。偏向锁的核心思想是,如果一个线程获得了锁,那么锁就进入偏向模式,此时Mark Word 的结构也变为偏向锁结构,当这个线程再次请求锁时,无需再做任何同步操作,即获取锁的过程,这样就省去了大量有关锁申请的操作,从而也就提供程序的性能。所以,对于没有锁竞争的场合,偏向锁有很好的优化效果,毕竟极有可能连续多次是同一个线程申请相同的锁。但是对于锁竞争比较激烈的场合,偏向锁就失效了,因为这样场合极有可能每次申请锁的线程都是不相同的,因此这种场合下不应该使用偏向锁,否则会得不偿失,需要注意的是,偏向锁失败后,并不会立即膨胀为重量级锁,而是先升级为轻量级锁。下面我们接着了解轻量级锁。

     因为java线程都是映射到操作系统原生的线程之上,如果要阻塞和唤醒一个线程,都需要操作系统从用户态切换到核心态,需要耗费很多处理器的性能和时间,如果是代码简单的同步块,状态转化的消耗可能比代码执行的时间还要长,所以synchronized是一个重量级锁

自旋锁与自适应自旋

互斥同步,对性能影响最大的是阻塞的实现,挂起线程和恢复线程的操作都需要转入内核状态完成,这些操作给系统的并发性能带来了很大的压力。同时,虚拟机开发团队也注意到很多应用上,共享数据的锁定状态只会持续很短的一段时间,为了这段时间去挂起和恢复线程并不值得。如果物理机上有一个以上的处理器,能让两个或两个以上的线程同时并行执行,我们就可以让后面请求锁的那个线程”稍等一下”,但不放弃处理器的执行时间,看看持有锁的线程是否很快就会释放锁。为了让线程等待,我们只需要让线程执行一个忙循环(自旋),这项技术就是所谓的自旋锁。

     在JDK1.4.2就已经引入了自旋锁,只不过默认是关闭的。自旋不能代替阻塞,且先不说处理器数量的要求,自旋等待本身虽然避免了线程切换的开销,但是它是要占据处理器时间的,因此如果锁被占用的时间很短,自旋等待的效果就非常好;反之,如果锁被占用的时间很长,那么自旋的线程只会白白消耗处理器资源,而不会做任何有用的工作,反而会带来性能上的浪费。因此自选等待必须有一定的限度,如果自旋超过了限定的次数仍然没有成功获得锁,就应当使用传统的方式去挂起线程了,自旋次数的默认值是10。

     在JDK1.6之后引入了自适应的自旋锁。自适应意味着自旋的时间不再固定了,而是由前一次在同一个锁上自旋的时间以及锁的拥有者的状态来决定。如果在同一个锁对象上,自旋等待刚刚获得过锁,并且持有锁的线程正在运行中,那么虚拟机就会认为这次自旋也很有可能再次成功,进而它将允许自旋等待持续相对更长的时间,比如100个循环。另外如果对于某一个锁,自旋很少成功获得过,那么在以后要获得这个锁时将可能忽略掉自旋过程,以避免浪费处理器资源。有了自适应自旋,随着程序运行和性能监控信息的不断完善,虚拟机对程序锁的状况预测就会越来越准确。

锁消除

消除锁是虚拟机另外一种锁的优化,这种优化更彻底,Java虚拟机在JIT编译时(可以简单理解为当某段代码即将第一次被执行时进行编译,又称即时编译),通过对运行上下文的扫描,去除不可能存在共享资源竞争的锁,通过这种方式消除没有必要的锁,可以节省毫无意义的请求锁时间,如下StringBuffer的append是一个同步方法,但是在add方法中的StringBuffer属于一个局部变量,并且不会被其他线程所使用,因此StringBuffer不可能存在共享资源竞争的情景,JVM会自动将其锁消除。

                                                                                    
----------------------------
原文链接:https://blog.csdn.net/qq_28938627/article/details/80892441

程序猿的技术大观园:www.javathinker.net



[这个贴子最后由 flybird 在 2020-02-24 12:49:24 重新编辑]
  Java面向对象编程-->Swing组件(上)
  JavaWeb开发-->开发JavaMail Web应用
  JSP与Hibernate开发-->Spring、JPA与Hibernate的整合
  Java网络编程-->Java网络编程入门
  精通Spring-->内部类
  Vue3开发-->Spring、Spring MVC与Java Web应用简介
  解密Java类文件的数据结构
  BST 二叉搜索树
  java 中文繁简体转换工具 opencc4j
  内部类的种类和用法
  最实用的10个重构小技巧排行榜,你都用过哪些?
  java常见的几种调用机制:同步调用,异步调用,回调
  volatile 与 synchronized 详解
  Java设计模式:传输对象模式
  Java设计模式:迭代器模式
  Java入门实用代码: 集合中添加元素
  Java入门实用代码:数组转集合
  Java入门实用代码:打印平行四边形
  Java入门实用代码:打印九九乘法表
  Java入门实用代码:删除一个文件目录
  类加载中的双亲委派模型
  更多...
 IPIP: 已设置保密
楼主      
该用户目前不在线 帕特泵 
威望: 未知
级别: 未知
魅力: 未知
经验: 未知
现金: 未知
发文章数: 未知
注册时间: 未知
 复制  引用


螺杆泵厂
上海螺杆泵
螺杆泵
螺杆油泵
磁力泵
化工泵
多级泵
离心泵
螺杆泵厂家
G型螺杆泵
污泥螺杆泵
离心泵
化工泵


焊接球阀
全焊接球阀
直埋全焊接球阀
埋地全焊接球阀
无级调速螺杆泵
磁力泵厂
化工泵厂
卫生螺杆泵
化工离心泵
多级泵
磁力泵
螺杆泵
隔膜计量泵

焊接球阀
供暖焊接球阀
法兰焊接球阀
上海焊接球阀


螺杆泵
磁力泵
化工泵
螺杆泵厂
污泥螺杆泵
发文章时间 2020-07-01 11:13:36
 IPIP: 已设置保密 1 楼     
1页 1条记录 当前第1
发表一个新主题 开启一个新投票 回复文章


中文版权所有: JavaThinker技术网站 Copyright 2016-2026 沪ICP备16029593号
荟萃Java程序员智慧的结晶,分享交流Java前沿技术。  联系我们
如有技术文章涉及侵权,请与本站管理员联系。