深入学习synchronized

一、Java内存模型JMM

在介绍JMM之前，先说说计算机的结构，冯诺依曼计算机结构：

1. CPU 是计算机运算和控制的核心，我们的程序最终都会变成指令让CPU去执行
2. 内存 程序都是在内存中运行的，内存会保存程序运行中的数据，供CPU处理
3. 缓存 由于CPU的运算速度和内存的读写速度差距很大，导致每次CPU操作内存都要耗费很长的时间，于是在CPU和内存之间加上缓存，最靠近CPU的缓存称为L1，然后依次是L2，L3和主内存，越靠近CPU的缓存速度越快，存储容量越小。CPU缓存模型结构如下：
   

---

二、Java内存模型JMM

Java内存模型是Java虚拟机定义的内存模型，Java内存模型是标准化的，主要是为了屏蔽底层不同计算机的区别。

Java内存模型主要分为俩部分：

• 主内存
  主内存是所有线程共享的，所有线程都能访问到的，所有的共享变量都存在于主内存中
• 工作内存
  每个线程都有自己的工作内存，工作内存中只存储该线程对共享变量的副本。线程对共享变量的所有操作（读写）都要在工作内存中完成，而不能直接操作主内存，处理完成之后再写回主内存，不同线程之间也不能访问对方工作内存中的变量
  

主内存和工作内存之间的交互
java内存模型中定义了8种操作完成主内存和工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存，直到工作内存完成操作后写回主内存的过程，每一个操作都是原子性的

需要注意的是：对一个变量执行lock操作，会清空工作内存中此变量的值，执行unlock操作的时候，必须要先把该变量的值同步到主内存中

---

三、synchronized保证三大特性

原子性

package day1;

/**
 * @author : Lxd
 * @date : 10:21 2021/7/21
 */
public class Test {
    static int count = 0;
    static final Object object = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized (object){
                    count++;
                }
            }
        },"t1");

        Thread t2 = new Thread(()->{
            for (int i = 5000; i > 0; i--) {
                synchronized (object){
                    count--;
                }
            }
        },"t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

对代码进行反汇编，可以发现count++ 和 count-- 的字节码指令如下：


在线程对count进行加一或者减一的操作的时候，会先获取到锁对象才能执行，获取到锁以后，假如在进行count++的某步中CPU时间片到了，但是另外一个线程获取不到锁，无法进行操作，最终还是由线程一执行操作，在线程1执行结束以后，会释放锁，这时候线程二获取锁进行操作。

可见性
synchronized相当于加一个lock，会刷新内存中的变量到工作内存中，保证了可见性

有序性
as-if-serial语义：不管编译器和CPU如何重新排序，必须保证在单线程情况下结果是正确的。

synchronized并不能保证有序性，但是使用了synchronized后只能有一个线程获得锁，就相当于单线程运作，遵循as-if-serial语义，结果是正确的

---

四、synchronized的特性

可重入：
一个线程可以多次获取synchronized，重复获取同一把锁

• 原理：synchronized的锁中有一个计数器（recursions变量），会记录线程获得几次锁，获得一次计数器加一，执行完同步代码块以后计数器减一，计数器为0的时候释放锁；
• 好处：可以避免死锁；可以更好的封装代码

不可中断：
一个线程获得锁后，另一个线程想要获得锁，必须处于阻塞获得等待状态，如果第一个线程不释放锁，第二个线程会一直阻塞或者等待，不可被中断，但是Lock是可中断的 ，通过trylock()实现，

---

五、反汇编学习synchronized

package day1;

/**
 * @author : Lxd
 * @date : 10:21 2021/7/21
 */
public class Test {
  private static final Object obj = new Object();

    public static void main(String[] args) {
        synchronized (obj){
            System.out.println("1");
        }
    }
    public synchronized void test(){
        System.out.println("test");
    }
}

反汇编以上代码，得到下面结果

在执行到同步代码块的时候，JVM会创建一个monitor对象，每个Java对象都和一个monitor监视器相关联，monitor对象有俩个重要的变量：

• 一个是owner，记录拥有该所的线程；
• 另一个是recursions，记录该线程获取锁的次数；
  当JVM执行某个线程内部的monitorenter时，它会尝试获取当前对象对应的monitor所有权，其过程如下：

1. 若monitor的进入数为0，线程可以进入monitor，将进入数变为1，当前线程成为montor的所有者；
2. 若线程已经是monitor的所有者，允许重入monitor，则进入monitor的进入数加一；
3. 若其他线程已经占有monitor的所有权，那么当前尝试获取monitor所有权的线将会被阻塞，直到monitor的进入数变为0，才能获取monitor的所有权；

synchronized同步代码块中出现异常，线程会释放锁

---

六、synchronized锁升级

1. CAS

首先看看原子类是怎么保证线程安全的，执行原子类的++操作；代码如下：

AtomicInteger atomicInteger = new AtomicInteger();
atomicInteger.incrementAndGet();

AtomicInteger 类代码如下：

private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
private volatile int value;

Unsafe类是Java中用于操作内存的类，相当于C的指针，但是官方不推荐使用，也无法直接创建这个类的实例

atomicInteger.incrementAndGet();代码如下：

public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

Unsafe类中的getAndAddInt方法如下：

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

CAS是怎么实现的这里就不说了，原子类的实现是通过CSA+volatile实现的。使用Unsafe类的CAS。

---

二、锁升级过程

无锁->偏向锁->轻量锁->重量锁

在JVM中，对象在内存中的布局分为3块区域：对象头、实例数据和对齐填充，对象头分为俩部分，Mark World和Kalss pointer

1. 偏向锁：
    当锁对象第一次被线程获取的时候，虚拟机会将对象头中的标志位置为“01”，即偏向模式。同时使用CAS操作把获取到这个锁的线程ID记录在对象头中的Mark word中，假如CAS操作成功，持有偏向锁的线程以后每次进入这个锁相关的同步代码的时候，虚拟机可以不再进行任何同步操作，偏向锁的效率比较高。
     不过一旦出现多个线程竞争锁的时候必须撤销偏向锁，也就是说偏向锁只能用于没有竞争的状态。
   好处：
    偏向锁在只有一个线程执行同步代码块的时候可以提高效率，适用于一个线程反复获得同一把锁的情况，偏向锁可以提高带有同步但无竞争的程序性能
2. 轻量级锁：
    当偏向锁关闭或者多个线程竞争偏向锁导致偏向锁升级为轻量级锁，则会尝试获取轻量级锁。在多线程交替执行同步代码块的时候效率比较高，可以避免重量级锁带来的性能消耗。
3. 自旋锁：
    monitor实现重量级锁的时候，会阻塞和唤醒线程，阻塞和唤醒需要CPU从用户态转换为内核态，比较消耗资源。假如俩个线程执行一个同步代码块，线程1抢到了锁，线程二就要进入阻塞状态，但是线程一执行同步代码块的时间可能会很快，这么短的时间内线程2需要进入阻塞再被唤醒，消耗的资源是很多的，这时就可以让线程一执行一个忙循环，等待一会而不是直接阻塞，这个就叫自旋锁。自旋的默认次数是10次。
4. 锁销除：
    锁消除是指在JIT运行的时候，对一些代码上要求同步，但是被检测到不可能存在共享数据竞争的锁进行的消除。
5. 锁粗化：
    JVM会探测到一连串的细小的操作都会使用同一个对象加锁，将同步代码块的范围放大，这样只需要加一次锁即可。

---

怎么优化synchronized

1. 减少synchronized中代码的行数，减少同步代码块的执行时间，减少锁的竞争
2. 降低synchronized锁的粒度，将一个锁拆分为多个锁提高并发度
   HashTable：锁定整个Hash表，一个操作正在进行的时候，其他的操作也会同时锁定，效率低下
   ConcurrentHashMap：局部锁定，只锁定桶，当对当前元素锁定的时候，其他元素不锁定
3. 读写分离，读的时候不加锁，写的时候加锁