对于synchronized关键字，作用应该都知道保证线程之间的同步性。准备从以下几个方面进行讲解。

1. synchronized关键字的用法
2. synchronized关键字不通用法在指令层面的异同点
3. synchronized的实现方式跟锁膨胀

1. synchronized关键字的用法

  synchronized关键字可以出现在方法签名跟代码块中。可以分为，同步代码块，同步方法，静态同步方法。这里用代码进行举例

/**
 * todo: synchronized解析示例
 *
 * @Author acy
 * @Date 2019/06/22
 */
public class SynchronizeTest {
    private static volatile int a = 1;
    private static volatile int b=0;
    @Test
    public void test() throws Exception {
        add();
        sub();
        mul();
        divide();
    }
      //代码块，其中代码块中的对象为一个类对象的Class对象最为锁，这种与synchronized static相同
    private void divide() {
        synchronized (SynchronizeTest.class){
            a=b/a;
        }
    }
        //代码块，其中以SynchronizeTest 作为做
    private void mul() {
        synchronized (this){
            b=a*a;
        }
    }
      //同步方法
    private synchronized void sub() {
        a--;
    }
    //静态同步方法
    private synchronized static void add() {
        a++;
    }
}

 对于同步代码块，当对象监视器不同（就是括号里面的所对象不同的时候）不同的同步代码块之间不能保证同步。相同的时候才能保证同步。
 对于使用对象的Class对象的代码块，当前的所对象是一个类的class对象，对等于静态同步方法 synchronized static。
 对于使用this作为对象监视器的代码块，当前的所对象是当前类对象，对等于非静态同步方法
（1）synchronized同步方法
1.对于其他synchronized同步方法或synchronized(this)同步代码块调用呈阻塞状态
2.同一时间只有一个线程可以执行synchronized同步方法中的代码
（2）synchronized(this)同步方法
1.对于其他synchronized同步方法或synchronized(this)同步代码块调用呈阻塞状态
2.同一时间只有一个线程可以执行synchronized(this)同步方法中的代码
 这里注意获取到synchronized锁的线程是无法被打断的

2. synchronized关键字不通用法在指令层面的异同点

 上面的代码使用Javap指令编译成指令之后的结果为

 private void divide();
    descriptor: ()V
    flags: ACC_PRIVATE
    Code:
      stack=2, locals=3, args_size=1
         0: ldc           #6                  // class com/SynchronizeTest
         2: dup
         3: astore_1
         4: monitorenter
         5: getstatic     #7                  // Field b:I
         8: getstatic     #8                  // Field a:I
        11: idiv
        12: putstatic     #8                  // Field a:I
        15: aload_1
        16: monitorexit
        17: goto          25
        20: astore_2
        21: aload_1
        22: monitorexit
             ......

  private void mul();
    descriptor: ()V
    flags: ACC_PRIVATE
    Code:
      stack=2, locals=3, args_size=1
         0: aload_0
         1: dup
         2: astore_1
         3: monitorenter
         4: getstatic     #8                  // Field a:I
         7: getstatic     #8                  // Field a:I
        10: imul
        11: putstatic     #7                  // Field b:I
        14: aload_1
        15: monitorexit
        16: goto          24
        19: astore_2
        20: aload_1
        21: monitorexit
           ......
  
  private synchronized void sub();
    descriptor: ()V
    flags: ACC_PRIVATE, ACC_SYNCHRONIZED
    Code:
         ......
  
  private static synchronized void add();
    descriptor: ()V
    flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNCHRONIZED
    Code:
         ......

}

1.同步代码块

 从上面可以看到对应的代码块方法里面多了monitorenter跟monitorexit。而且其中monitorexit有两个是什么原因呢，下面进行说明。

1. monitorenter跟monitorexit的作用
    关于monitorenter解释这里引用sun官方的解释：monitorenter操作的目标一定要是一个对象，类型是reference。Reference实际就是堆里的一个存放对象的地 址。每个对象（reference）都有一个monitor对应，如果有其它的线程获取了这个对象的monitor，当前的线程就要一直等待，直到获得 monitor的线程放弃monitor，当前的线程才有机会获得monitor。与之对应的monitorexit表示释放对象的monitor。
2. 为什么有两个monitorexit
    第一个是代码正常结束的时候运行的，第二个是代码执行发生异常的时候确保释放锁的。

2.同步方法

 在同步方法中没有看到对应的monitorenter跟monitorexit。那是通过什么来获取锁对应的信息的呢。可以看到对应的flags上面多了ACC_SYNCHRONIZED标志。ACC_SYNCHRONIZED在jvm规范中是这么解释的，在调用synchronized方法时候，会先去检查运行时常量池的method_info结构中的access_flags中是否有ACC_SYNCHRONIZED标志（method_info是Java对象解析之后保存方法相关信息的结构）。如果ACC_SYNCHRONIZED存在，则执行线程进入监视器，调用方法本身，并退出监视器，方法调用是正常还是突然完成。在执行线程拥有监视器期间，没有其他线程可以输入它。如果在调用synchronized方法期间抛出异常并且synchronized方法未处理异常，则在从方法重新抛出异常之前，将自动退出该方法的监视器synchronized。

3.synchronized的实现方式跟锁膨胀

1.Java对象头

 synchronized用的锁是存在Java对象头里面的。如果对象时数组类型，则虚拟机用3个字存储对象头，如果是非数组类型，则用2字宽存储对象头。</br>

 Java对象头里面的Mark Word里面默认存储对象的HashCode，分代年龄和锁标记类型。

2.锁的升级和对比

 锁一共有4中状态，级别从低到高依次是：无所状态，偏向锁状态，轻量级锁状态和重量级锁状态，这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级。这种升级却不能降级的策略，目的是为了提高获得锁和释放锁的效率
其中偏向锁实在1.6的时候加上的

• 偏向锁

 偏向锁的作用是，让同一个线程再次获取同一个锁的时候，不用再次去竞争锁，降低了获得锁的代价。
 当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步块时候不需要进行CAS操作来加锁和解锁，只需要简单的检测一下对象头的Mark Word里面是否存储着指向当前线程的偏向锁。
 测试成功，表示线程已经获得了锁；测试失败，则需要再测试一下Mark Word中偏向锁的标识是否设置成了1，如果没有设置，则使用CAS竞争锁；如果设置了，则尝试CAS将对象头的偏向锁指向当前线程（简而言之先检测对象头的线程ID，有则无后续，没有就要竞争）
 （1）偏向锁的撤销
 偏向锁使用了一种等到竞争才会出现释放锁的机制，所以当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁。偏向锁的撤销，需要等待全局安全点。首先会暂停拥有偏向锁的线程，然后检查持有偏向锁的线程是否活着，如果线程不处于活动状态，则会将对象头设置为无锁状态；如果线程仍然活着，拥有偏向锁的栈会被执行，遍历偏向对象的锁记录，栈中的锁记录和对象头的Mark Word要么重新偏向于其他线程，要么恢复到无锁或者标记对象不适合作为偏向锁，最后唤醒暂停的线程
 （2）关闭偏向锁
 偏向锁在Java6和7默认是启用的，但是它在应用程序启动几秒钟之后才激活，如果有必要可以使用JVM参数来关闭延迟：-XX:BiasedLockingStartupDelay=0。可以使用JVM参数-XX:-UseBiasedLocking=false关闭偏向锁，那么程序默认会进入轻量级锁状态

偏向锁的加锁跟撤销

• 轻量级锁

 （1）轻量级锁加锁
 线程在执行同步块之前，JVM会先在当前线程的栈帧中创建用于存储锁记录的空间，并将对象头中的Mark Word复制到锁记录中。然后线程尝试使用CAS将对象头中的Mark Word替换未指向锁记录的指针如果成功，当前线程获得锁，如果失败，表示其他线程竞争锁，当前线程便会尝试使用自旋来获取锁。
 （2）轻量级锁解锁
 轻量级解锁时，会使用原子的CAS操作将对象头中的Mark Word替换回到对象头，如果成功，则表示没有竞争发生。如果失败，表示当前锁存在竞争，锁就会膨胀为重量级锁。
 自旋会消耗CPU，为了避免无用的自旋，一旦锁升级为重量级锁，就不会再恢复到轻量级锁状态。当锁处于这个状态下，其他线程试图获取锁时，就会被阻塞，当持有锁的线程释放锁之后会唤醒这些线程，进行新一轮的锁的争夺

无锁->轻量级->重量级

 关于CAS后续的文章会进行讲解