Java【有与无】【F2】Synchronized

最新推荐文章于 2023-11-16 09:16:18 发布

琴韵

最新推荐文章于 2023-11-16 09:16:18 发布

阅读量188

点赞数

分类专栏： Java 文章标签： Java Synchronized

本文链接：https://blog.csdn.net/u012549626/article/details/98594735

版权

Java 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

1.简介

造成线程安全问题的主要诱因：

存在共享数据(也称临界资源)
存在多条线程共同操作共享数据

解决方案

（互斥锁）

当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行；当一个共享数据被当前正在访问的线程加上互斥锁后，在同一个时刻，其他线程只能处于等待的状态，直到当前线程处理完毕释放该锁；在 Java 中，关键字 synchronized可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块，synchronized可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到

2.应用方式

修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁。
修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁。
修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象。

2.1.实例方法

public class AccountingSync implements Runnable {
    
    /**
     * 共享资源(临界资源)
     */
    static int i = 0;
    
    /**
     * synchronized 修饰实例方法
     */
    public synchronized void increase(){
        i++;
    }
    
    @Override
    public void run() {
        for(int j=0; j < 1000000; j++){
            increase();
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        // 1.加锁同一对象，线程安全可以保证
        AccountingSync instance=new AccountingSync();
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        
        // 2.加锁不同对象，线程安全无法保证
        // Thread t1=new Thread(new AccountingSyncBad());
        // Thread t2=new Thread(new AccountingSyncBad());

        t1.start();
        t2.start();
        //join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

开启两个线程操作同一个共享资源即变量i，由于i++;操作并不具备原子性，该操作是先读取值，然后写回一个新值，相当于原来的值加上1，分两步完成，如果第二个线程在第一个线程读取旧值和写回新值期间读取i的域值，那么第二个线程就会与第一个线程一起看到同一个值，并执行相同值的加1操作，这也就造成了线程安全失败，因此对于increase方法必须使用synchronized修饰，以便保证线程安全。此时我们应该注意到synchronized修饰的是实例方法increase，在这样的情况下，当前线程的锁便是实例对象instance，注意Java中的线程同步锁可以是任意对象。从代码执行结果来看确实是正确的，倘若我们没有使用synchronized关键字，其最终输出结果就很可能小于2000000，这便是synchronized关键字的作用。

当一个线程正在访问一个对象的 synchronized 实例方法，那么其他线程不能访问该对象的其他 synchronized 方法，毕竟一个对象只有一把锁，当一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，所以无法访问该对象的其他synchronized实例方法，但是其他线程还是可以访问该实例对象的其他非synchronized方法，当然如果是一个线程 A 需要访问实例对象 obj1 的 synchronized 方法 f1(当前对象锁是obj1)，另一个线程 B 需要访问实例对象 obj2 的 synchronized 方法 f2(当前对象锁是obj2)，这样是允许的，因为两个实例对象锁并不同相同，此时如果两个线程操作数据并非共享的，线程安全是有保障的，遗憾的是如果两个线程操作的是共享数据，那么线程安全就有可能无法保证了。

2.2.静态方法

/**
 * 由于synchronized关键字修饰的是静态increase方法，与修饰实例方法不同的是，其锁对象是当前类的class对象。
 * @Date 2019/8/6 16:02
 */
public class AccountingSyncStatic implements Runnable {
    /**
     * 共享资源(临界资源)
     */
    static int i = 0;
    
    /**
     * synchronized 修饰静态方法，锁是当前class对象，也就是AccountingSyncStatic类对应的class对象
     *
     */
    public static synchronized void increase(){
        i++;
    }
    
    /**
     * synchronized 修饰实例方法
     * 其对象锁是当前实例对象，如果别的线程调用该方法，将不会产生互斥现象，毕竟锁对象不同；
     * 此种情况线程锁对象不同，线程安全无法保证
     */
    public synchronized void increase2(){
        i++;
    }
    
    @Override
    public void run() {
        for(int j=0; j < 1000000; j++){
            increase();
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        //new新实例
        Thread t1=new Thread(new AccountingSyncStatic());
        //new新实例
        Thread t2=new Thread(new AccountingSyncStatic());
        //启动线程
        t1.start();
        t2.start();
        //join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

2.3.同步代码块

/**
 * 在某些情况下，我们编写的方法体可能比较大，同时存在一些比较耗时的操作，而需要同步的代码又只有一小部分，如果直接对整个方法进行同步操作，可能会得不偿失，此时我们可以使用同步代码块的方式对需要同步的代码进行包裹，这样就无需对整个方法进行同步操作了
 * @Date 2019/8/6 16:44
 */
public class AccountingSyncCodeBlock implements Runnable {
    
    static AccountingSyncCodeBlock instance = new AccountingSyncCodeBlock();
    
    static int i=0;
    
    @Override
    public void run() {
        //1.使用同步代码块对变量i进行同步操作,锁对象为instance
        synchronized(instance){
            for(int j=0; j<1000000; j++){
                i++;
            }
        }
        //2.this,当前实例对象锁,等同1
//        synchronized(this){
//            for(int j=0;j<1000000;j++){
//                i++;
//            }
//        }
        //3.class对象锁,等同1
//        synchronized(AccountingSync.class){
//            for(int j=0;j<1000000;j++){
//                i++;
//            }
//        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();
        t2.start();
        //join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

每次当线程进入synchronized包裹的代码块时就会要求当前线程持有instance实例对象锁，如果当前有其他线程正持有该对象锁，那么新到的线程就必须等待，这样也就保证了每次只有一个线程执行i++;操作。

3.底层语义原理

Java 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现，无论是显式同步(有明确的 monitorenter 和 monitorexit 指令,即同步代码块)还是隐式同步都是如此。在 Java 语言中，同步用的最多的地方可能是被 synchronized 修饰的同步方法。同步方法并不是由 monitorenter 和 monitorexit 指令来实现同步的，而是由方法调用指令读取运行时常量池中方法的 ACC_SYNCHRONIZED 标志来隐式实现的。

3.1.理解Java对象头与Monitor

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

实例变量：存放类的属性数据信息，包括父类的属性信息，如果是数组的实例部分还包括数组的长度，这部分内存按4字节对齐。
填充数据：由于虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的，仅仅是为了字节对齐
Java头对象：它实现synchronized的锁对象的基础

3.1.1.Java头对象

一般而言，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默认存储结构外，还有如下可能变化的结构：

锁状态	25bit		4bit	1bit	2bit
锁状态	23bit	2bit	4bit	是否偏向锁	锁标记位
轻量级锁	指向栈中锁记录的指针				00
重量级锁	指向互斥量（重量级锁）的指针				10
GC标记	空				11
偏向锁	线程ID	Epoch	对象分代年龄	1	01

其中轻量级锁和偏向锁是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中的原因，下面我们将进一步分析synchronized在字节码层面的具体语义实现。

3.2.代码块底层原理

public class AccountingSyncCodeBlock implements Runnable {
    
    static AccountingSyncCodeBlock instance = new AccountingSyncCodeBlock();
    
    static int i=0;
    
    @Override
    public void run() {
        //1.使用同步代码块对变量i进行同步操作,锁对象为instance
        synchronized(instance){
            for(int j=0; j<1000000; j++){
                i++;
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();
        t2.start();
        //join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

将上述代码反编译的字节码如下：

D:\JDK8\bin>javap.exe -c -v "D:\java8\out\java9\production\java8\cn\sync\AccountingSyncCodeBlock.class"
Classfile /D:/java8/out/java9/production/java8/cn/sync/AccountingSyncCodeBlock.class
  Last modified 2019-8-7; size 1199 bytes
  MD5 checksum b92d5d37355ffd1014da0ffdf4c1ece7
  Compiled from "AccountingSyncCodeBlock.java"
public class cn.sync.AccountingSyncCodeBlock implements java.lang.Runnable
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:                            // 常量池中数据
   #1 = Methodref          #13.#42        // java/lang/Object."<init>":()V
   #2 = Fieldref           #11.#43        // cn/sync/AccountingSyncCodeBlock.instance:Lcn/sync/AccountingSyncCodeBlock;
   #3 = Integer            1000000
   #4 = Fieldref           #11.#44        // cn/sync/AccountingSyncCodeBlock.i:I
   #5 = Class              #45            // java/lang/Thread
   #6 = Methodref          #5.#46         // java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
   #7 = Methodref          #5.#47         // java/lang/Thread.start:()V
   #8 = Methodref          #5.#48         // java/lang/Thread.join:()V
   #9 = Fieldref           #49.#50        // java/lang/System.out:Ljava/io/PrintStream;
  #10 = Methodref          #51.#52        // java/io/PrintStream.println:(I)V
  #11 = Class              #53            // cn/sync/AccountingSyncCodeBlock
  #12 = Methodref          #11.#42        // cn/sync/AccountingSyncCodeBlock."<init>":()V
  #13 = Class              #54            // java/lang/Object
  #14 = Class              #55            // java/lang/Runnable
  #15 = Utf8               instance
  #16 = Utf8               Lcn/sync/AccountingSyncCodeBlock;
  #17 = Utf8               i
  #18 = Utf8               I
  #19 = Utf8               <init>
  #20 = Utf8               ()V
  #21 = Utf8               Code
  #22 = Utf8               LineNumberTable
  #23 = Utf8               LocalVariableTable
  #24 = Utf8               this
  #25 = Utf8               run
  #26 = Utf8               j
  #27 = Utf8               StackMapTable
  #28 = Class              #54            // java/lang/Object
  #29 = Class              #56            // java/lang/Throwable
  #30 = Utf8               main
  #31 = Utf8               ([Ljava/lang/String;)V
  #32 = Utf8               args
  #33 = Utf8               [Ljava/lang/String;
  #34 = Utf8               t1
  #35 = Utf8               Ljava/lang/Thread;
  #36 = Utf8               t2
  #37 = Utf8               Exceptions
  #38 = Class              #57            // java/lang/InterruptedException
  #39 = Utf8               <clinit>
  #40 = Utf8               SourceFile
  #41 = Utf8               AccountingSyncCodeBlock.java
  #42 = NameAndType        #19:#20        // "<init>":()V
  #43 = NameAndType        #15:#16        // instance:Lcn/sync/AccountingSyncCodeBlock;
  #44 = NameAndType        #17:#18        // i:I
  #45 = Utf8               java/lang/Thread
  #46 = NameAndType        #19:#58        // "<init>":(Ljava/lang/Runnable;)V
  #47 = NameAndType        #59:#20        // start:()V
  #48 = NameAndType        #60:#20        // join:()V
  #49 = Class              #61            // java/lang/System
  #50 = NameAndType        #62:#63        // out:Ljava/io/PrintStream;
  #51 = Class              #64            // java/io/PrintStream
  #52 = NameAndType        #65:#66        // println:(I)V
  #53 = Utf8               cn/sync/AccountingSyncCodeBlock
  #54 = Utf8               java/lang/Object
  #55 = Utf8               java/lang/Runnable
  #56 = Utf8               java/lang/Throwable
  #57 = Utf8               java/lang/InterruptedException
  #58 = Utf8               (Ljava/lang/Runnable;)V
  #59 = Utf8               start
  #60 = Utf8               join
  #61 = Utf8               java/lang/System
  #62 = Utf8               out
  #63 = Utf8               Ljava/io/PrintStream;
  #64 = Utf8               java/io/PrintStream
  #65 = Utf8               println
  #66 = Utf8               (I)V
{
  static cn.sync.AccountingSyncCodeBlock instance;
    descriptor: Lcn/sync/AccountingSyncCodeBlock;
    flags: ACC_STATIC

  static int i;
    descriptor: I
    flags: ACC_STATIC

  public cn.sync.AccountingSyncCodeBlock();
    descriptor: ()V
    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 7: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcn/sync/AccountingSyncCodeBlock;
  
  //===========主要看看下面的实现================
  public void run();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=4, args_size=1
         0: getstatic     #2                  // Field instance:Lcn/sync/AccountingSyncCodeBlock;
         3: dup
         4: astore_1
         5: monitorenter                      // 进入同步方法
         6: iconst_0
         7: istore_2
         8: iload_2
         9: ldc           #3                  // int 1000000
        11: if_icmpge     28
        14: getstatic     #4                  // Field i:I
        17: iconst_1
        18: iadd
        19: putstatic     #4                  // Field i:I
        22: iinc          2, 1
        25: goto          8
        28: aload_1
        29: monitorexit                       // 退出同步方法
        30: goto          38
        33: astore_3
        34: aload_1
        35: monitorexit                       // 退出同步方法
        36: aload_3
        37: athrow
        38: return
      Exception table:
         from    to  target type
             6    30    33   any
            33    36    33   any
      LineNumberTable:
        line 16: 0
        line 17: 6
        line 18: 14
        line 17: 22
        line 20: 28
        line 33: 38
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            8      20     2     j   I
            0      39     0  this   Lcn/sync/AccountingSyncCodeBlock;
      StackMapTable: number_of_entries = 4
        frame_type = 253 /* append */
          offset_delta = 8
          locals = [ class java/lang/Object, int ]
        frame_type = 250 /* chop */
          offset_delta = 19
        frame_type = 68 /* same_locals_1_stack_item */
          stack = [ class java/lang/Throwable ]
        frame_type = 250 /* chop */
          offset_delta = 4

  public static void main(java.lang.String[]) throws java.lang.InterruptedException;
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=3, args_size=1
         0: new           #5                  // class java/lang/Thread
         3: dup
         4: getstatic     #2                  // Field instance:Lcn/sync/AccountingSyncCodeBlock;
         7: invokespecial #6                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
        10: astore_1
        11: new           #5                  // class java/lang/Thread
        14: dup
        15: getstatic     #2                  // Field instance:Lcn/sync/AccountingSyncCodeBlock;
        18: invokespecial #6                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
        21: astore_2
        22: aload_1
        23: invokevirtual #7                  // Method java/lang/Thread.start:()V
        26: aload_2
        27: invokevirtual #7                  // Method java/lang/Thread.start:()V
        30: aload_1
        31: invokevirtual #8                  // Method java/lang/Thread.join:()V
        34: aload_2
        35: invokevirtual #8                  // Method java/lang/Thread.join:()V
        38: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
        41: getstatic     #4                  // Field i:I
        44: invokevirtual #10                 // Method java/io/PrintStream.println:(I)V
        47: return
      LineNumberTable:
        line 36: 0
        line 37: 11
        line 38: 22
        line 39: 26
        line 41: 30
        line 42: 34
        line 43: 38
        line 44: 47
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      48     0  args   [Ljava/lang/String;
           11      37     1    t1   Ljava/lang/Thread;
           22      26     2    t2   Ljava/lang/Thread;
    Exceptions:
      throws java.lang.InterruptedException

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=2, locals=0, args_size=0
         0: new           #11                 // class cn/sync/AccountingSyncCodeBlock
         3: dup
         4: invokespecial #12                 // Method "<init>":()V
         7: putstatic     #2                  // Field instance:Lcn/sync/AccountingSyncCodeBlock;
        10: iconst_0
        11: putstatic     #4                  // Field i:I
        14: return
      LineNumberTable:
        line 9: 0
        line 11: 10
}
SourceFile: "AccountingSyncCodeBlock.java"

从字节码中可知同步语句块的实现使用的是monitorenter 和 monitorexit 指令；

其中monitorenter指令指向同步代码块的开始位置，monitorexit指令则指明同步代码块的结束位置；

当执行monitorenter指令时，当前线程将试图获取 objectref(即对象锁) 所对应的 monitor 的持有权，当 objectref 的 monitor 的进入计数器为 0，那线程可以成功取得 monitor，并将计数器值设置为 1，取锁成功；

如果当前线程已经拥有 objectref 的 monitor 的持有权，那它可以重入这个 monitor，重入时计数器的值也会加 1。倘若其他线程已经拥有 objectref 的 monitor 的所有权，那当前线程将被阻塞，直到正在执行线程执行完毕，即monitorexit指令被执行，执行线程将释放 monitor(锁)并设置计数器值为0 ，其他线程将有机会持有 monitor ；

值得注意的是编译器将会确保无论方法通过何种方式完成，方法中调用过的每条 monitorenter 指令都有执行其对应 monitorexit 指令，而无论这个方法是正常结束还是异常结束；

为了保证在方法异常完成时 monitorenter 和 monitorexit 指令依然可以正确配对执行，编译器会自动产生一个异常处理器，这个异常处理器声明可处理所有的异常，它的目的就是用来执行 monitorexit 指令；

从字节码中也可以看出多了一个monitorexit指令，它就是异常结束时被执行的释放monitor 的指令；

3.3.方法底层原理

public class AccountingSync implements Runnable {
    
    /**
     * 共享资源(临界资源)
     */
    static int i = 0;
    
    /**
     * synchronized 修饰实例方法
     */
    public synchronized void increase(){
        i++;
    }
    
    @Override
    public void run() {
        for(int j=0; j < 1000000; j++){
            increase();
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        AccountingSync instance=new AccountingSync();
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();
        t2.start();
        //join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

将上述代码反编译的字节码如下：

D:\JDK8\bin>javap.exe -c -v "D:\java8\out\java9\production\java8\cn\sync\AccountingSync.class"
Classfile /D:/java8/out/java9/production/java8/cn/sync/AccountingSync.class
  Last modified 2019-8-7; size 1166 bytes
  MD5 checksum 3d3b217a57f4135e6236e96c67fcc4e4
  Compiled from "AccountingSync.java"
public class cn.sync.AccountingSync implements java.lang.Runnable
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #13.#41        // java/lang/Object."<init>":()V
   #2 = Fieldref           #5.#42         // cn/sync/AccountingSync.i:I
   #3 = Integer            1000000
   #4 = Methodref          #5.#43         // cn/sync/AccountingSync.increase:()V
   #5 = Class              #44            // cn/sync/AccountingSync
   #6 = Methodref          #5.#41         // cn/sync/AccountingSync."<init>":()V
   #7 = Class              #45            // java/lang/Thread
   #8 = Methodref          #7.#46         // java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
   #9 = Methodref          #7.#47         // java/lang/Thread.start:()V
  #10 = Methodref          #7.#48         // java/lang/Thread.join:()V
  #11 = Fieldref           #49.#50        // java/lang/System.out:Ljava/io/PrintStream;
  #12 = Methodref          #51.#52        // java/io/PrintStream.println:(I)V
  #13 = Class              #53            // java/lang/Object
  #14 = Class              #54            // java/lang/Runnable
  #15 = Utf8               i
  #16 = Utf8               I
  #17 = Utf8               <init>
  #18 = Utf8               ()V
  #19 = Utf8               Code
  #20 = Utf8               LineNumberTable
  #21 = Utf8               LocalVariableTable
  #22 = Utf8               this
  #23 = Utf8               Lcn/sync/AccountingSync;
  #24 = Utf8               increase
  #25 = Utf8               run
  #26 = Utf8               j
  #27 = Utf8               StackMapTable
  #28 = Utf8               main
  #29 = Utf8               ([Ljava/lang/String;)V
  #30 = Utf8               args
  #31 = Utf8               [Ljava/lang/String;
  #32 = Utf8               instance
  #33 = Utf8               t1
  #34 = Utf8               Ljava/lang/Thread;
  #35 = Utf8               t2
  #36 = Utf8               Exceptions
  #37 = Class              #55            // java/lang/InterruptedException
  #38 = Utf8               <clinit>
  #39 = Utf8               SourceFile
  #40 = Utf8               AccountingSync.java
  #41 = NameAndType        #17:#18        // "<init>":()V
  #42 = NameAndType        #15:#16        // i:I
  #43 = NameAndType        #24:#18        // increase:()V
  #44 = Utf8               cn/sync/AccountingSync
  #45 = Utf8               java/lang/Thread
  #46 = NameAndType        #17:#56        // "<init>":(Ljava/lang/Runnable;)V
  #47 = NameAndType        #57:#18        // start:()V
  #48 = NameAndType        #58:#18        // join:()V
  #49 = Class              #59            // java/lang/System
  #50 = NameAndType        #60:#61        // out:Ljava/io/PrintStream;
  #51 = Class              #62            // java/io/PrintStream
  #52 = NameAndType        #63:#64        // println:(I)V
  #53 = Utf8               java/lang/Object
  #54 = Utf8               java/lang/Runnable
  #55 = Utf8               java/lang/InterruptedException
  #56 = Utf8               (Ljava/lang/Runnable;)V
  #57 = Utf8               start
  #58 = Utf8               join
  #59 = Utf8               java/lang/System
  #60 = Utf8               out
  #61 = Utf8               Ljava/io/PrintStream;
  #62 = Utf8               java/io/PrintStream
  #63 = Utf8               println
  #64 = Utf8               (I)V
{
  static int i;
    descriptor: I
    flags: ACC_STATIC

  public cn.sync.AccountingSync();
    descriptor: ()V
    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 10: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcn/sync/AccountingSync;

  //============主要关注内容=================
  public synchronized void increase();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED       // 关注点
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field i:I
         3: iconst_1
         4: iadd
         5: putstatic     #2                  // Field i:I
         8: return
      LineNumberTable:
        line 21: 0
        line 22: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   Lcn/sync/AccountingSync;

  public void run();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=2, args_size=1
         0: iconst_0
         1: istore_1
         2: iload_1
         3: ldc           #3                  // int 1000000
         5: if_icmpge     18
         8: aload_0
         9: invokevirtual #4                  // Method increase:()V
        12: iinc          1, 1
        15: goto          2
        18: return
      LineNumberTable:
        line 26: 0
        line 27: 8
        line 26: 12
        line 29: 18
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            2      16     1     j   I
            0      19     0  this   Lcn/sync/AccountingSync;
      StackMapTable: number_of_entries = 2
        frame_type = 252 /* append */
          offset_delta = 2
          locals = [ int ]
        frame_type = 250 /* chop */
          offset_delta = 15

  public static void main(java.lang.String[]) throws java.lang.InterruptedException;
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=4, args_size=1
         0: new           #5                  // class cn/sync/AccountingSync
         3: dup
         4: invokespecial #6                  // Method "<init>":()V
         7: astore_1
         8: new           #7                  // class java/lang/Thread
        11: dup
        12: aload_1
        13: invokespecial #8                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
        16: astore_2
        17: new           #7                  // class java/lang/Thread
        20: dup
        21: aload_1
        22: invokespecial #8                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
        25: astore_3
        26: aload_2
        27: invokevirtual #9                  // Method java/lang/Thread.start:()V
        30: aload_3
        31: invokevirtual #9                  // Method java/lang/Thread.start:()V
        34: aload_2
        35: invokevirtual #10                 // Method java/lang/Thread.join:()V
        38: aload_3
        39: invokevirtual #10                 // Method java/lang/Thread.join:()V
        42: getstatic     #11                 // Field java/lang/System.out:Ljava/io/PrintStream;
        45: getstatic     #2                  // Field i:I
        48: invokevirtual #12                 // Method java/io/PrintStream.println:(I)V
        51: return
      LineNumberTable:
        line 32: 0
        line 33: 8
        line 34: 17
        line 35: 26
        line 36: 30
        line 38: 34
        line 39: 38
        line 40: 42
        line 41: 51
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      52     0  args   [Ljava/lang/String;
            8      44     1 instance   Lcn/sync/AccountingSync;
           17      35     2    t1   Ljava/lang/Thread;
           26      26     3    t2   Ljava/lang/Thread;
    Exceptions:
      throws java.lang.InterruptedException

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: iconst_0
         1: putstatic     #2                  // Field i:I
         4: return
      LineNumberTable:
        line 15: 0
}
SourceFile: "AccountingSync.java"

从字节码中可以看出，synchronized修饰的方法并没有monitorenter指令和monitorexit指令，取得代之的确实是ACC_SYNCHRONIZED标识，该标识指明了该方法是一个同步方法；

JVM通过该ACC_SYNCHRONIZED访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用；

Java 6之前，synchronized属于重量级锁，效率低，因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，而操作系统实现线程之间的切换时需要从用户态转换到核心态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高；

Java 6之后，为了减少获得锁和释放锁所带来的性能消耗，引入了轻量级锁和偏向锁；

3.4.Java虚拟机对synchronized的优化

详细过程可以查阅《深入理解Java虚拟机原理》

锁的状态：

无锁状态
偏向锁
轻量级锁
重量级锁

随着锁的竞争，锁可以从偏向锁升级到轻量级锁，再升级的重量级锁，但是锁的升级是单向的，也就是说只能从低到高升级，不会出现锁的降级；

3.4.1.偏向锁

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

3.4.2.轻量级锁

倘若偏向锁失败，虚拟机并不会立即升级为重量级锁，它还会尝试使用一种称为轻量级锁的优化手段(1.6之后加入的)，此时Mark Word 的结构也变为轻量级锁的结构。轻量级锁能够提升程序性能的依据是“对绝大部分的锁，在整个同步周期内都不存在竞争”，注意这是经验数据。需要了解的是，轻量级锁所适应的场景是线程交替执行同步块的场合，如果存在同一时间访问同一锁的场合，就会导致轻量级锁膨胀为重量级锁。

3.4.3.自旋锁

轻量级锁失败后，虚拟机为了避免线程真实地在操作系统层面挂起，还会进行一项称为自旋锁的优化手段。这是基于在大多数情况下，线程持有锁的时间都不会太长，如果直接挂起操作系统层面的线程可能会得不偿失，毕竟操作系统实现线程之间的切换时需要从用户态转换到核心态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，因此自旋锁会假设在不久将来，当前的线程可以获得锁，因此虚拟机会让当前想要获取锁的线程做几个空循环(这也是称为自旋的原因)，一般不会太久，可能是50个循环或100循环，在经过若干次循环后，如果得到锁，就顺利进入临界区。如果还不能获得锁，那就会将线程在操作系统层面挂起，这就是自旋锁的优化方式，这种方式确实也是可以提升效率的。最后没办法也就只能升级为重量级锁了。

3.4.5.锁消除

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

4.关键点

4.1.可重入性

从互斥锁的设计上来说，当一个线程试图操作一个由其他线程持有的对象锁的临界资源时，将会处于阻塞状态，但当一个线程再次请求自己持有对象锁的临界资源时，这种情况属于重入锁，请求将会成功，在java中synchronized是基于原子性的内部锁机制，是可重入的，因此在一个线程调用synchronized方法的同时在其方法体内部调用该对象另一个synchronized方法，也就是说一个线程得到一个对象锁后再次请求该对象锁，是允许的，这就是synchronized的可重入性。

/**
 * synchronized的可重入性
 * @Date 2019/8/7 9:48
 */
public class AccountingSyncReentrant implements Runnable {
    
    static AccountingSyncReentrant instance = new AccountingSyncReentrant();
    
    static int i = 0;
    static int j = 0;
    
    public synchronized void increase(){
        j++;
    }
    @Override
    public void run() {
        for(int j = 0; j < 1000000; j++){
            //this,当前实例对象锁
            synchronized(this){
                i++;
                increase();
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();
        t2.start();
        //join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

获取当前实例对象锁后进入synchronized代码块执行同步代码，并在代码块中调用了当前实例对象的另外一个synchronized方法，再次请求当前实例锁时，将被允许，进而执行方法体代码，这就是重入锁最直接的体现，需要特别注意另外一种情况，当子类继承父类时，子类也是可以通过可重入锁调用父类的同步方法。注意由于synchronized是基于monitor实现的，因此每次重入，monitor中的计数器仍会加1。

4.1.线程中断

在线程运行(run方法)中间打断它，在Java中，提供了以下3个有关线程中断的方法

//中断线程（实例方法）
public void Thread.interrupt();

//判断线程是否被中断（实例方法）
public boolean Thread.isInterrupted();

//判断是否被中断并清除当前中断状态（静态方法）
public static boolean Thread.interrupted();

当一个线程处于被阻塞状态或者试图执行一个阻塞操作时，使用Thread.interrupt()方式中断该线程，注意此时将会抛出一个InterruptedException的异常，同时中断状态将会被复位(由中断状态改为非中断状态)

/**
     * 阻塞状态,线程中断
     * @throws InterruptedException
     */
    private static void blockingState() throws InterruptedException {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                try {
                    while (true) {
                        //当前线程处于阻塞状态，异常必须捕捉处理，无法往外抛出
                        TimeUnit.SECONDS.sleep(2);
                    }
                } catch (InterruptedException e) {
                    System.out.println("中断睡眠");
                    boolean interrupt = this.isInterrupted();
                    //中断状态被复位
                    System.out.println("中断: "+interrupt);
                }
            }
        };
        t1.start();
        TimeUnit.SECONDS.sleep(2);
        //中断处于阻塞状态的线程
        t1.interrupt();
    }
    
    /**
     * 非阻塞状态,线程中断
     * @throws InterruptedException
     */
    private static void notBlockingState() throws InterruptedException {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                while (true) {
                    //判断当前线程是否被中断
                    if (this.isInterrupted()) {
                        System.out.println("线程中断");
                        break;
                    }
                }
                System.out.println("已跳出循环,线程中断!");
            }
        };
        t1.start();
        TimeUnit.SECONDS.sleep(2);
        //中断处于阻塞状态的线程
        t1.interrupt();
    }
    
    /**
     * 综合
     * @throws InterruptedException
     */
    private static void comprehensive() throws InterruptedException {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                try {
                    //判断当前线程是否已中断,注意interrupted方法是静态的,执行后会对中断状态进行复位
                    while (!Thread.interrupted()) {
                        TimeUnit.SECONDS.sleep(2);
                    }
                } catch (InterruptedException e) {
                    System.out.println("中断睡眠");
                    boolean interrupt = this.isInterrupted();
                    //中断状态被复位
                    System.out.println("中断: "+interrupt);
                }
            }
        };
        t1.start();
        TimeUnit.SECONDS.sleep(2);
        //中断处于阻塞状态的线程
        t1.interrupt();
    }

中断情况

当线程处于阻塞状态或者试图执行一个阻塞操作时，可以使用实例方法interrupt()进行线程中断，执行中断操作后将会抛出interruptException异常(该异常必须捕捉无法向外抛出)并将中断状态复位
当线程处于运行状态时，我们也可调用实例方法interrupt()进行线程中断，但同时必须手动判断中断状态，并编写中断线程的代码(其实就是结束run方法体的代码)

事实上线程的中断操作对于正在等待获取的锁对象的synchronized方法或者代码块并不起作用，也就是对于synchronized来说，如果一个线程在等待锁，那么结果只有两种，要么它获得这把锁继续执行，要么它就保存等待，即使调用中断线程的方法，也不会生效。

public class SynchronizedBlocked implements Runnable {
    
    public synchronized void sync() {
        System.out.println("尝试调用sync()");
        while(true){
            // 它让出当前线程 CPU 的时间片，使正在运行中的线程重新变成就绪状态，并重新竞争 CPU 的调度权。它可能会获取到，也有可能被其他线程获取到。
            Thread.yield();
        }
    }
    
    /**
     * 在构造器中创建新线程并启动获取对象锁
     */
    public SynchronizedBlocked() {
        //该线程已持有当前实例锁
        new Thread() {
            @Override
            public void run() {
                // 此线程获取的锁
                sync();
            }
        }.start();
    }
    
    @Override
    public void run() {
        //中断判断
        while (true) {
            if (Thread.interrupted()) {
                System.out.println("中断线程!!");
                break;
            } else {
                sync();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        SynchronizedBlocked sync = new SynchronizedBlocked();
        Thread t = new Thread(sync);
        //启动后调用sync()方法,无法获取当前实例锁处于等待状态
        t.start();
        TimeUnit.SECONDS.sleep(1);
        //中断线程,无法生效
        t.interrupt();
    }
}

在SynchronizedBlocked构造函数中创建一个新线程并启动获取调用sync()获取到当前实例锁，由于SynchronizedBlocked自身也是线程，启动后在其run方法中也调用了sync()，但由于对象锁被其他线程占用，导致t线程只能等到锁，此时调用了t.interrupt();并不能中断线程。

4.2.等待唤醒机制

所谓等待唤醒机制本篇主要指的是notify/notifyAll和wait方法，在使用这3个方法时，必须处于synchronized代码块或者synchronized方法中，否则就会抛出IllegalMonitorStateException异常，这是因为调用这几个方法前必须拿到当前对象的监视器monitor对象，也就是说notify/notifyAll和wait方法依赖于monitor对象，在前面的分析中，知道monitor 存在于对象头的Mark Word 中(存储monitor引用指针)，而synchronized关键字可以获取 monitor ，这也就是为什么notify/notifyAll和wait方法必须在synchronized代码块或者synchronized方法调用的原因。

synchronized (obj) {
   obj.wait();
   obj.notify();
   obj.notifyAll();         
 }

需要特别理解的一点是，与sleep方法不同的是wait方法调用完成后，线程将被暂停，但wait方法将会释放当前持有的监视器锁(monitor)，直到有线程调用notify/notifyAll方法后方能继续执行，而sleep方法只让线程休眠并不释放锁。同时notify/notifyAll方法调用后，并不会马上释放监视器锁，而是在相应的synchronized(){}/synchronized方法执行结束后才自动释放锁。