Java基础、中级、高级、架构面试资料
    你的位置：业余草 > JAVA > Java 锁粗化与循环

    Java 锁粗化与循环

    JAVA herman 1989浏览
    公告：“业余草”微信公众号提供免费CSDN下载服务(只下Java资源)，关注业余草微信公众号，添加作者微信：xttblog2，发送下载链接帮助你免费下载！
    本博客日IP超过2000，PV 3000 左右，急需赞助商。
    极客时间所有课程通过我的二维码购买后返现24元微信红包，请加博主新的微信号：xttblog2，之前的微信号好友位已满，备注：返现
    受密码保护的文章请关注“业余草”公众号，回复关键字“0”获得密码
    所有面试题(java、前端、数据库、springboot等)一网打尽，请关注文末小程序
    视频教程免费领
    腾讯云】1核2G5M轻量应用服务器50元首年，高性价比，助您轻松上云

    锁粗化（Lock Coarsening）。锁粗化是合并使用相同锁对象的相邻同步块的过程。如果编译器不能使用锁省略（Lock Elision）消除锁，那么可以使用锁粗化来减少开销。

    众所周知，Hotspot 确实进行了锁粗化优化，可以有效合并几个相邻同步块，从而降低锁开销。能够把下面的代码：

    synchronized (obj) {
  // 语句 1
}
synchronized (obj) {
  // 语句 2
}

    转化为：

    synchronized (obj) {
  // 语句 1
  // 语句 2
}

    问题来了，Hotspot 能否对循环进行这种优化？例如，把

    for (...) {
  synchronized (obj) {
    // 一些操作
  }
}

    优化成下面这样？

    synchronized (this) {
  for (...) {
     // 一些操作
  }
}

    理论上，没有什么能阻止我们这样做，甚至可以把这种优化看作只针对锁的优化，像 loop unswitching 一样。然而，缺点是可能把锁优化后变得过粗，线程在执行循环时会占据所有的锁。

    Loop unswitching 是一种编译器优化技术。通过复制循环主体，在 if 和 else 语句中放一份循环体代码，实现将条件句的内部循环移到循环外部，进而提高循环的并行性。由于处理器可以快速运算矢量，因此执行速度得到提升。

    要回答这个问题，最简单的办法就是找到 Hotspot 优化的证据。幸运的是，有了 JMH 帮助这项工作变得非常简单。JMH 不仅在构建基准测试时有用，并且在分析基准测试方面同样好用。让我们从一个简单的基准测试开始：

    @Fork(..., jvmArgsPrepend = {"-XX:-UseBiasedLocking"})
@State(Scope.Benchmark)
public class LockRoach {
    int x;

    @Benchmark
    @CompilerControl(CompilerControl.Mode.DONT_INLINE)
    public void test() {
        for (int c = 0; c < 1000; c++) {
            synchronized (this) {
                x += 0x42;
            }
        }
    }
}

    完整的代码，在这里：https://shipilev.net/jvm/anatomy-quarks/1-lock-coarsening-for-loops/LockRoach.java

    这里有一些重要的技巧：

    1. 使用 -XX:-UseBiasedLocking 禁用偏向锁（Biased Lock）可以避免启动时间过长。由于偏向锁不会立即启动，在初始化阶段要等待5秒钟（参见 BiasedLockingStartupDelay 选项）
    2. 禁用 @Benchmark 方法内联操作可以帮助我们从反汇编中分离相关内容
    3. 加上“魔数” 0x42 有助于快速从反汇编中定位加法操作

    偏向锁（Biased Locking）。尽管 CAS 原子指令相对于重量级锁来说开销比较小，但还是存在非常可观的本地延迟，为了在无锁竞争的情况下避免取锁获过程中执行不必要的 CAS 原子指令提出了偏向锁技术。

    运行环境 i7 4790K、Linux x86_64、JDK EA 9b156：

    Benchmark            Mode  Cnt      Score    Error  Units
LockRoach.test       avgt    5   5331.617 ± 19.051  ns/op

    从上面运行数据能分析出什么结果？什么都看不出来，对吧？我们需要调查背后到底发生了什么。这时 -prof perfasm 配置可以派上用场，它能显示生成代码中的热点区域。用默认设置运行，能够发现最热的指令是加锁 lock cmpxchg（CAS），而且只打印指令附近的代码。-prof perfasm:mergeMargin=1000 配置可以将这些热点区域合并保存为输出片段，乍看之下可能觉得有点恐怖。

    进一步分析得出连续的跳转指令是锁定或解锁，注意循环次数最多的代码（第一列），可以看到最热的循环像下面这样：

    ↗  0x00007f455cc708c1: lea    0x20(%rsp),%rbx
 │          < 省略若干代码，进入 monitor >     ; <--- coarsened（粗化）!
 │  0x00007f455cc70918: mov    (%rsp),%r10        ; 加载 $this
 │  0x00007f455cc7091c: mov    0xc(%r10),%r11d    ; 加载 $this.x
 │  0x00007f455cc70920: mov    %r11d,%r10d        ; ...hm...
 │  0x00007f455cc70923: add    $0x42,%r10d        ; ...hmmm...
 │  0x00007f455cc70927: mov    (%rsp),%r8         ; ...hmmmmm!...
 │  0x00007f455cc7092b: mov    %r10d,0xc(%r8)     ; LOL Hotspot，冗余存储，下面省略两行
 │  0x00007f455cc7092f: add    $0x108,%r11d       ; 加 0x108 = 0x42 * 4 <-- 展开4次
 │  0x00007f455cc70936: mov    %r11d,0xc(%r8)     ; 把 $this.x 回省略若干代码，退出 monitor >      ; <--- coarsened（粗化）!
 │  0x00007f455cc709c6: add    $0x4,%ebp          ; c += 4   <--- 展开4次
 │  0x00007f455cc709c9: cmp    $0x3e5,%ebp        ; c < 1000?
 ╰  0x00007f455cc709cf: jl     0x00007f455cc708c1

    哈哈。循环似乎被展开了4次，然后这4个迭代中实现锁粗化！为了排除循环展开对锁粗化的影响，我们可以通过-XX:LoopUnrollLimit=1 配置裁剪循环展开，再次量化受限后的粗化性能。

    Loop unrolling（循环展开），也称 Loop unwinding，是一种循环转换技术。它试图以牺牲二进制大小为代价优化程序的执行速度，这种方法被称为时空折衷。转换可以由程序员手动执行，也可以由编译器优化。

    Benchmark            Mode  Cnt      Score    Error  Units

# Default
LockRoach.test       avgt    5   5331.617 ± 19.051  ns/op

# -XX:LoopUnrollLimit=1
LockRoach.test       avgt    5  20679.043 ±  3.133  ns/op

    哇，性能提升了4倍！显而易见的，因为我们已经观察到最热的指令是加锁 lock cmpxchg。当然，4倍后的粗化锁意味着4倍吞吐量。非常酷，我们是不是可以宣布成功，然后继续前进？还没有。我们必须验证禁用循环展开真正提供了我们想要进行比较的内容。perfasm 的结果似乎表明它含有类似的热点循环，只是跨了一大步。

    ↗  0x00007f964d0893d2: lea    0x20(%rsp),%rbx
 │          < 省略若干代码，进入 monitor >
 │  0x00007f964d089429: mov    (%rsp),%r10        ; 加载 $this
 │  0x00007f964d08942d: addl   $0x42,0xc(%r10)    ; $this.x += 0x42
 │          < 省略若干代码，退出 monitor >
 │  0x00007f964d0894be: inc    %ebp               ; c++
 │  0x00007f964d0894c0: cmp    $0x3e8,%ebp        ; c < 1000?
 ╰  0x00007f964d0894c6: jl     0x00007f964d0893d2 ;

    当锁粗化在整个循环中不起作用时，一旦中间看起来好像存在 N 个相邻的加锁解锁操作，另一种循环优化——循环展开会提供常规锁粗化。这将提高性能，并有助于限制粗化的范围，以避免长循环过度粗化。

    英文原文链接：https://shipilev.net/jvm/anatomy-quarks/1-lock-coarsening-for-loops/

    业余草公众号

    最后，欢迎关注我的个人微信公众号：业余草（yyucao）！可加作者微信号：xttblog2。备注：“1”，添加博主微信拉你进微信群。备注错误不会同意好友申请。再次感谢您的关注！后续有精彩内容会第一时间发给您！原创文章投稿请发送至532009913@qq.com邮箱。商务合作也可添加作者微信进行联系！

    本文原文出处：业余草： » Java 锁粗化与循环

    相关文章推荐