synchronized

一、synchronized介绍

线程安全问题的主要诱因

　　存在共享数据（也称临界资源）

　　存在多条线程共同操作这些数据

解决问题的根本方法：

　　同一时刻有且只有一个线程操作共享数据，其它线程必须等待该线程处理完数据后再对共享数据进行操作。

互斥锁的特性

互斥性： 即在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程的协调机制，这样在同一时间只有一个线程对需要同步的代码块（复合操作）进行访问。互斥性也称操作的原子性。

可见性：必须确保在锁被释放之前，对共享变量所做的修改，对应随后获得该锁的另一个线程是可见的（即获得锁的同时应获得最新共享变量的值），否则另一个线程可能是在本地缓存某个副本上继续操作，从而引起不一致。

synchronized锁的不是代码，锁的都是对象。

根据获取锁的分类： 获取对象锁和获取类锁

获取对象锁的两种用法

1、同步代码块（ synchronized(this),  synchronized(类实例对象) ），锁是括号() 中的实例对象。

2、同步非静态方法( synchronized method) ,锁是当前对象的实例对象

获取类锁的两种用法

1、同步代码块（synchronized（类.class））, 锁的是小括号()中的类对象(Class对象).

2、同步静态方法 (synchronized static method ) , 锁是当前对象的类对象 (Class对象）

二、synchronized底层实现原理

实现synchronized基础

Java对象头

Monitor

对象在内存中的布局

对象头

实例数据

对齐填充

对象头的结构

Mark Word

Monitor： 每个Java对象天生自带了一把看不见的锁

进入源码： http://hg.openjdk.java.net/jdk8u/hs-dev/hotspot/file/ae5624088d86/src/share/vm/runtime/objectMonitor.hpp

可以发现里面有两个队列 _WaitSet 和 _EntryList

 _owner 指向持有objectMonitor的线程

下面从字节码的角度查看synchronize

创建类

public class SyncBlockAndMethod {

    public void syncsTask(){
        synchronized (this){
            System.out.println("Hello");
        }
    }

    public synchronized void syncTask(){
        System.out.println("Hello again");
    }

}

　　然后编译成class文件

javac SyncBlockAndMethod.java

查看字节码

javap -verbose SyncBlockAndMethod.class

Classfile /xxx/src/thread/SyncBlockAndMethod.class
  Last modified 2019-12-29; size 613 bytes
  MD5 checksum 9aa751fc8ed2cf7d372724572edfb1a8
  Compiled from "SyncBlockAndMethod.java"
public class thread.SyncBlockAndMethod
  SourceFile: "SyncBlockAndMethod.java"
  minor version: 0
  major version: 51
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #7.#20         //  java/lang/Object."<init>":()V
   #2 = Fieldref           #21.#22        //  java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #23            //  Hello
   #4 = Methodref          #24.#25        //  java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = String             #26            //  Hello again
   #6 = Class              #27            //  thread/SyncBlockAndMethod
   #7 = Class              #28            //  java/lang/Object
   #8 = Utf8               <init>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               syncsTask
  #13 = Utf8               StackMapTable
  #14 = Class              #27            //  thread/SyncBlockAndMethod
  #15 = Class              #28            //  java/lang/Object
  #16 = Class              #29            //  java/lang/Throwable
  #17 = Utf8               syncTask
  #18 = Utf8               SourceFile
  #19 = Utf8               SyncBlockAndMethod.java
  #20 = NameAndType        #8:#9          //  "<init>":()V
  #21 = Class              #30            //  java/lang/System
  #22 = NameAndType        #31:#32        //  out:Ljava/io/PrintStream;
  #23 = Utf8               Hello
  #24 = Class              #33            //  java/io/PrintStream
  #25 = NameAndType        #34:#35        //  println:(Ljava/lang/String;)V
  #26 = Utf8               Hello again
  #27 = Utf8               thread/SyncBlockAndMethod
  #28 = Utf8               java/lang/Object
  #29 = Utf8               java/lang/Throwable
  #30 = Utf8               java/lang/System
  #31 = Utf8               out
  #32 = Utf8               Ljava/io/PrintStream;
  #33 = Utf8               java/io/PrintStream
  #34 = Utf8               println
  #35 = Utf8               (Ljava/lang/String;)V
{
  public thread.SyncBlockAndMethod();
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 6: 0

  public void syncsTask();
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: aload_0
         1: dup
         2: astore_1
         3: monitorenter
         4: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         7: ldc           #3                  // String Hello
         9: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        12: aload_1
        13: monitorexit
        14: goto          22
        17: astore_2
        18: aload_1
        19: monitorexit
        20: aload_2
        21: athrow
        22: return
      Exception table:
         from    to  target type
             4    14    17   any
            17    20    17   any
      LineNumberTable:
        line 9: 0
        line 10: 4
        line 11: 12
        line 12: 22
      StackMapTable: number_of_entries = 2
           frame_type = 255 /* full_frame */
          offset_delta = 17
          locals = [ class thread/SyncBlockAndMethod, class java/lang/Object ]
          stack = [ class java/lang/Throwable ]
           frame_type = 250 /* chop */
          offset_delta = 4


  public synchronized void syncTask();
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #5                  // String Hello again
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 15: 0
        line 16: 8
}

　　可以发现有monitorenter 和monitorexit 两条指令

另外一个方法，没有monitorenter 和monitorexit 两条指令。可以看到ACC_SYNCHRONIZED的访问标志，用来区分一个方法是否是同步方法。当发现有同步标志，执行线程将持有Monitor。

为什么会对synchronized嗤之以鼻？

早期版本中，synchronized属于重量级锁，依赖于Mutex Lock实现

线程之间的切换需要从用户态转换为核心态，开销较大

Java6以后，synchronized性能得到了很大的提升

自旋锁和自适应自旋锁

自旋锁：

　　许多情况下，共享数据的锁定状态持续时间较短，切换线程不值得

　　通过让线程执行忙循环等待锁的释放，不让出CPU

　　缺点： 若锁被其它线程长时间占用，会带来许多性能上的开销

自适应自旋锁

　　自旋的次数不再固定

　　由前一次在同一个锁上的自旋时间以及锁的拥有者的状态来决定。

synchronized的四种状态

无锁，偏向锁，轻量级锁， 重量级锁

锁膨胀方向： 无锁 -> 偏向锁  -> 轻量级锁 -> 重量级锁

偏向锁： 减少同一线程获取锁的代价

大多数情况下，锁不存在多线程竞争，总是由同一线程多次获得

核心思想：

如果一个线程获得了锁，那么锁就进入了偏向模式，此时Mark Word的结构也变为偏向锁结构，当该线程再次请求锁时，无需再做任何同步操作，即获取锁的过程只需要检查Mark Word的锁标记位为偏向锁以及当前线程Id等于Mark Word的ThreadId即可，这样就省去了大量有关锁申请的操作。

不适用于锁竞争比较激烈的多线程场合。

轻量级锁

　　轻量级锁是由偏向锁升级来的，偏向锁运行在一个线程进入同步块的情况下，当第二个线程加入锁争用的时候，偏向锁就好升级为轻量级锁。

　　适用的场景： 线程交替执行同步块

　　若存在同一时间访问同一锁的情况，就好导致轻量级锁膨胀为重量级锁。

偏向锁、轻量级锁、重量级锁的汇总