浅谈synchronized

学习地址： 黑马

1、synchronized原理

1. Java中每一个对象都可以作为锁，具体有三种形式：
   1. 对于普通方法，锁是当前实例对象
   2. 对于静态同步方法，锁是当前类的Class对象
   3. 对于同步方法块，锁是Synchronized括号里配置的对象。
2. 经过编译之后，synchronized会被编译成monitorenter+代码逻辑+monitorexit。
   
3. monitorenter和monitorexit这两个字节码指令都需要一个reference类型的参数来指定要锁定和解锁的对象。如果Java源码中synchronized明确指明了参数对象，那就以这个对象的引用作为reference。如果没有明确指明，那么根据synchronized修饰的方法类型决定，是取代码所在的对象实例还是取类型对应的Class对象来作为线程持有的锁。
4. 在monitorenter指令时，首先要去尝试获取对象的锁。如果这个对象没被锁定，或者当前线程已经持有了那个对象的锁，就把锁的计数器的值增加一，而在执行monitorexit指令时会将锁计数器的值减一。一旦计数器的值为零，锁随即就被释放了。如果获取对象锁失败，那当前线程就应当被阻塞等待，直到请求锁定的对象被持有它的线程释放为止。
5. 注：monitorexit插入在方法结束处和异常处，JVM保证每个monitorenter必须有对应的monitorexit，synchronized出现异常也会释放锁。

2、synchronized优化

1. 优化是在JDK1.6进行的

2.1、CAS

尚硅谷-面试第二季CAS

1. CAS全称：Compare And Swap（比较并交换），是CPU并发原语。
2. 功能是判断内存某个位置的值是否为预期值，如果是，就更新为行的值，这个过程是原子的（底层通过unsafe类保证更新）。
3. 由于CAS是一种系统原语，原语属于操作系统用于范畴，是由若干条指令组成，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致的问题，也就是说CAS是线程安全的。
4. 举例

public class CASDemo {
    public static void main(String[] args) {
        // 创建一个原子类
        AtomicInteger atomicInteger = new AtomicInteger(5);

        /**
         * 一个是期望值，一个是更新值，但期望值和原来的值相同时，才能够更改
         * 假设三秒前，我拿的是5，也就是expect为5，然后我需要更新成 2019
         */
        System.out.println(atomicInteger.compareAndSet(5, 2019) + "\t current data: " + atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(5, 1024) + "\t current data: " + atomicInteger.get());
    }
}

这是因为我们执行第一个的时候，期望值和原本值是满足的，因此修改成功，但是第二次后，主内存的值已经修改成了2019，不满足期望值，因此返回了false，本次写入失败。

2.1.1、CAS底层原理

1. AtomicInteger.getAndIncrement()方法的源码
   
   这里调用了一个unsafe类的getAndAddInt方法。

2.1.1.1、unsafe类

1. unsafe是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（Native）方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定的内存数据。Unsafe类存在sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中的CAS操作的执行依赖于Unsafe类的方法。
2. 注意Unsafe类的所有方法都是native修饰的，也就是说unsafe类中的方法都直接调用操作系统底层资源执行相应的任务。
3. 这就解释了Atomic修饰的包装类能够保证原子性，依靠的就是底层的unsafe类。

2.1.1.2、变量valueOffset

1. 表示该变量的值在内存中的便宜地址，unsafe就是根据内存便宜地址获取数据的。
   
2. 那么getAndIncrement就是通过valueOffset，直接通过内存地址获取到值，然后进行+1操作。

2.1.1.3、变量value用volatile修饰

1. 这样保证了多线程之间的内存可见性。
   
   1. var5：就是我们从主内存中拷贝到工作内存中的值(每次都要从主内存拿到最新的值到自己的本地内存，然后执行compareAndSwapInt()在再和主内存的值进行比较。因为线程不可以直接越过高速缓存，直接操作主内存，所以执行上述方法需要比较一次，在执行加1操作)。
   2. 假设执行 compareAndSwapInt返回false，那么就一直执行 while方法，直到期望的值和真实值一样。
      1. var1：AtomicInteger对象本身。
      2. var2：该对象值的引用地址。
      3. var4：需要变动的数量。
      4. var5：用var1和var2找到内存中的真实值（用该对象当前的值和var5比较，如果相同更行var5+var4并返回true，否则，继续取值然后再比较，直到更新完成）。
2. 这里没有用synchronized，而用CAS，这样提高了并发性，也能够实现一致性，是因为每个线程进来后，进入的do while循环，然后不断的获取内存中的值，判断是否为最新，然后在进行更新操作。

2.1.2、CAS总结

1. CAS是compareAndSwap，比较当前工作内存中的值和主物理内存中的值，如果相同则执行规定操作，否者继续比较直到主内存和工作内存的值一致为止。
2. CAS有3个操作数，内存值V，旧的预期值A，要修改的更新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否者什么都不做

2.2、Java对象布局

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

2.2.1、Java对象头

1. synchronized用的锁是存在Java对象头中的。
2. Java对象头的MarkWord默认存储对象的HashCode、分代年龄、锁标记位。在运行期间，MarkWord存储的数据会随着锁标志位的变化而变化。
   

2.3、synchronized锁升级过程

1. JDK1.6为了减少获得锁和释放锁带来的性能消耗，引入了偏向锁和轻量级锁。
2. 级别从低到高：无锁、偏向锁、轻量级锁、重量级锁。
3. 会随着竞争情况逐渐升级。锁可以升级但不能降级。

2.3.1、偏向锁

1. 大多数情况，锁不仅不存在多线程竞争，而且总是由同一个线程多次获取的，如果每次都是获得重量级锁，那么锁的获取的释放会带来大量性能消耗，为了让线程获得锁代价更小就引入了偏向锁。
2. 当一个线程访问同步代码块并获得锁的时候，会在对象头和栈帧中的锁记录里面记录偏向的线程ID，以后该线程在进入和退出同步代码块的时候不需要进行CAS操作来加锁和解锁的，只需要简单测试一下对象头的MarkWord里面是否存储着指向当前线程的偏向锁。
3. 如果测试成功，表示线程已经获得了锁；测试失败，需要再测试一下MarkWord中偏向锁的标识是否已经设置成1；
   1. 如果没有设置，使用CAS竞争
   2. 设置了，尝试使用CAS将对象头的偏向锁指向当前线程。

2.3.1.1、偏向锁撤销

1. 偏向锁使用一种等待竞争出现才释放锁的机制，所以当其他线程尝试竞争偏向锁的时候，持有偏向锁的线程才会释放锁。

2.3.2、轻量级锁

1. 轻量级是相对于使用monitor的传统锁而言的。
2. 当偏向锁运行在一个线程进入同步代码块的情况下，当第二个线程加入锁争用的时候偏向锁就升级为轻量级锁。
3. 线程在执行同步代码块的时候，JVM会先在当前线程的栈帧中创建用于存储锁记录的空间，并将对象头中的MarkWord复制到锁记录中，成为DisplacedMarkWord。
4. 然后线程尝试使用CAS将对象头中的MarkWord替换为指向锁记录的指针。
   1. 如果成功，那么当前线程获得锁
   2. 如果失败，表示其他线程竞争锁，当前线程便尝试使用自旋来获取锁。

2.3.2.1、轻量级锁解锁

1. 会使用原子的CAS操作将DisplacedMarkWord替换回到对象头，如果成功，表示没有竞争发生。如果失败，表示当前锁存在竞争，锁就会膨胀成重量级锁。

2.4、锁的优缺点对比

学习：
synchronized底层原理