多线程笔记

逃离我推掉我的手 2023-06-30 11:55 2阅读 0赞

### 多线程笔记 ###

*  并发编程中的三个问题
 *   *  可见性
     *  原子性
     *  有序性
 *  jmm
 *  synchronized是如何解决这三个问题的
 *  synchronized的两大特性：可重入 和不可中断
 *  synchronized原理剖析
 *  面试题: synchronized与Lock的区别
 *  synchronized的偏向锁模式
 *  CAS概述和作用
 *  java对象布局
 *   偏 向 锁 的 原 理 \\color\{red\}\{偏向锁的原理\} 偏向锁的原理
 *  轻量级锁
 *   自 旋 锁 \\color\{red\}\{自旋锁\} 自旋锁
 *  锁消除
 *  锁粗化
 *  锁优化

# 并发编程中的三个问题 #

## 可见性 ##

一个线程对共享变量进行了修改，另一个线程马上就能得到其修改后的最新值  
可见性问题代码测试：

public class App 
    { 
        /** *1. 先创建一个共享变量 */
        public static boolean flag=true;
        public static void main( String[] args ) throws InterruptedException { 
            /** * 2.创建一个线程不断地去读共享变量 */
            new Thread(()->{ 
                while (flag){ 
    
                }
            }).start();
            Thread.sleep(TimeUnit.SECONDS.toSeconds(10));
            /** * 创建一个线程去读取变量 */
            new Thread(()->{ 
                flag=false;
                System.out.println("线程修改了变量flag的值为false");
            }).start();
           
        }
    }

![在这里插入图片描述][20200117152213742.png]  
所以线程1还在无限循环的运行  
[多线程中join的用法][join]

## 原子性 ##

在一次或多次操作中，要么所有的操作都执行，并且不会受其他因素的干扰而中断，要么所有的操作都不执行。【我对一个变量需要进行++，然后再–操作。遵循原子性的话：我只有完成了++和–后或者我不对他操作，你才能对该变量进行操作。比方我正在++，还没有–，你跑过来操作了该变量，进行了–，那么该变量就会被多减少了一次。共享变量要保证原子性（就相当于该变量对我来说是私有的，我在操作时，该变量对其他人而言就是不可见的）】  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70]

代码测试如下：

public class App 
    { 
        /** *1. 定义共享变量number * 2.对number进行1000次的++操作 * 3.使用5个线程来进行 */
        public static int number=0;
        public static void main( String[] args ) throws InterruptedException { 
            /** * 2.创建一个线程不断地去读共享变量 */
           Runnable increment=()->{ 
               for (int i=0;i<1000;i++){ 
                   number++;
               }
           };
            List<Thread>list=new ArrayList<>();
            //使用5个线程来操作
            for (int i=0;i<5;i++){ 
                Thread t=new Thread(increment);
                t.start();
                list.add(t);
            }
            for (Thread t:list){ 
                //join的作用：保证5个线程都执行完，才打印共享变量number的值,他还可以保证线程按顺序执行
                t.join();
                //至于这里是没new一个Thread，然后add，而非a.join(b.join(c))
            }
            System.out.println("number:"+number);
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 1]

## 有序性 ##

代码的执行顺序。java在编译期/运行期会对代码进行优化，导致程序执行顺序并不一定是编写代码的顺序。  
代码测试如下：

@State
    @JCStressTest
    @Outcome(id={ "1","4"},expect = Expect.ACCEPTABLE,desc = "ok")
    @Outcome(id="0",expect = Expect.ACCEPTABLE_INTERESTING,desc = "danger")
    public class App
    { 
       int num=0;
       boolean ready=false;
       //线程执行的代码
    
        /** * jcstress它是并发压力测试 * 线程对actorl和actor2的执行是随机的 * I_Result记录了对num操作过程中的值 */
        @Actor
        public void actorl(I_Result r){ 
            if (ready){ 
                r.r1=num+num;
            }else { 
                r.r1=1;
            }
        }
        //线程2执行的代码
        @Actor
        public void actor2(I_Result r){ 
            /** * 编译期由于重排序，实际代码执行顺序是 * ready=true; * num=2; * 这样就会导致结果0的出现 */
            num=2;
            ready=true;
        }
    }
    /** *相关依赖  <dependency> <groupId>org.openjdk.jcstress</groupId> <artifactId>jcstress-core</artifactId> <version>0.5</version> </dependency> */

![在这里插入图片描述][20200117203226768.png]

# jmm #

jmm它是一种规范：它的提出，就是为了解决多线程读写共享变量时的原子性/可见性/有序性的问题(共享变量的访问规则)。—即synchronize,votatitle,java把内存看作两部分，主内存（共享变量（类变量和实例变量））和工作内存（存放线程局部变量，线程要执行代码，必须要在工作内存中处理----必须先把共享变量赋值一份到自己的工作内存里面来处理，处理好了再放回主内存里面去）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 2]  
jmm是一个抽象出来的概念(规范)，他和真实的内存架构之间的如下：

> cpu一级缓存，速度最快，但容量较小，往后是二级缓存，三级缓存。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 3]  
工作内存既可以是cpu寄存器，缓存，还可以是内存，主内存也一样（既可以是cpu寄存器，缓存，还可以是内存），真实内存其实并没有主内存和工作内存一说。主内存和工作内存只是java为了方便描述共享变量的访问规则，所以造出来的词，类似磁感线这一概念一样。

java定义了8中原子操作，用于主内存和工作内存之间的数据交互（协议）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 4]

> 假设线程1想访问共享变量x，首先会作原子操作read（其实就是读取共享变量x），接着就是load（将共享变量加载到工作内存中），接着是use，线程操作工作内存中的值，假设返回一个新的结果false，Assgin就是将false赋值给工作内存中的变量x，然后是store，保存这个x=false，write就是把最新的值x=false，同步（写回）主内存中。如果对共享变量加锁了才会有lock（一定是先清空工作内存中x，才会lock，接着进行read），unlock（一定是先write工作内存中的值到主内存才会unlock）这两个原子操作  
> lock—>read—>load–>use–>assign–>store–>write–>unlock

# synchronized是如何解决这三个问题的 #

synchronize保证可见性是和lock，unlock有关：

线程1先拿到静态变量，准备常量1，将变量number和常量1相加，这是线程2过来了（cpu切换到线程2，线程2尝试获得锁），但线程2又拿不到锁，只能在外面等待（线程2放弃cpu的时间片，阻塞了），此时cpu会切换到线程1，让它继续完成后面的操作。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 5]

synchronization保证原子性的原理：保证只有一个线程能够拿到锁，进入到代码块里面

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 6]  
如果对共享变量加了volatile，则当一个线程进行完write之后，jmm根据缓存一致性协议，会把其他工作内存中的值设为失效，这时线程就会来读最新的值

synchronization他会实时刷新工作内存中的值，故它可以保证可见性。（会执行lock原子操作，然后执行read，use，assign，write，即刷新工作内存中的值）system.out.println(""),println里面有synchronization关键字。

重排序：  
改变一下代码的顺序，可能提高cpu的执行效率。  
只要不影响单线程下cpu的程序执行结果，就可以重排序。一下不能进行重排序

synchronization如何保证重排序后的有序性的  
加了synchronization依然有重排序，但是由于有了锁机制，同步代码块，它可以保证只有一个线程执行同步代码块里面的代码。从而保证有序性。

as-if-serial语义：不管编译器和cpu如何 重排序，必须保证单线程情况下程序的结果时正确的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 7]  
加了volatile的共享变量不会发生重拍序。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 8]

# synchronized的两大特性：可重入 和不可中断 #

一个线程可多次执行synchronized，重复获取通过同一把锁

可重入的原理：  
synchronized的锁对象有一个计数器（recursions变量）会记录线程获得了几次锁。执行完同步代码块，数量会-1，当数量为0时，会释放锁  
可重入的好处：  
可避免死锁（线程进入了同步代码块，如果没有可重入特性，那么就不能再次进入同步代码块了，会卡在这里，很容易发生死锁 ）  
可更好的封装代码（一个同步代码块里面可调用静态方法【里面还是同步代码块】）

public class Demo { 
        public static void main(String[] args) { 
            new MyThread().start();
            new MyThread().start();
        }
        /** * 1.定义线程类 * 2.在run方法中使用嵌套的同步代码块 * 3.使用两个线程来执行 */
    
        /*可更好的封装代码 public static void test(){ synchronized (MyThread.class){ System.out.println(Thread.currentThread().getName()+"进入了同步代码块"); } }*/
    
        static class MyThread extends Thread{ 
            @Override
            public void run() { 
                synchronized (MyThread.class){ 
                    System.out.println(getName()+"进入了同步代码块");
                    /*Demo.test();*/
                    synchronized (MyThread.class){ 
                        System.out.println(getName()+"进入了同步代码块");
                    }
                }
            }
        }
    }

不可中断：  
一个线程获得锁，另一个线程也想获得锁，必须处于阻塞或等待状态。如果一个线程不释放锁，另一个线程会一直阻塞或等待，不可被中断

public class Demo { 
        /** * 1.定义Runabke * 2在Runabke中定义同步代码块 * 3.开启线程执行同步，保证不退出同步 * 4.后开启线程执行同步（阻塞状态） * 5.停止第二个线程 */
        private static Object obj=new Object();
         public static void main(String[] args) throws InterruptedException { 
           Runnable run=()->{ 
               synchronized (obj){ 
                   System.out.println(Thread.currentThread().getName()+"进入了同步代码块 ");
                   try { 
                       TimeUnit.SECONDS.sleep(88888888);//先阻塞一会
                       Thread.sleep(88888888);//先阻塞一会
                   } catch (InterruptedException e) { 
                       e.printStackTrace();
                   }
               }
           };
           Thread t1=new Thread(run);
           t1.start();
           Thread.sleep(100);
             /** * 如果没有代码 Thread.sleep(100);，程序结果如下： * 停止线程前 * Thread-0进入了同步代码块 * 停止线程后 * RUNNABLE * RUNNABLE */
           Thread t2=new Thread(run);
             t2.start();
            System.out.println("停止线程前");
           t2.interrupt();//停掉第二个线程---由于synchronized的不可中断，线程会一直等待你下去，不会被终结
            System.out.println("停止线程后");
            System.out.println(t1.getState());
            System.out.println(t2.getState());
        }
    
        /** * 程序运行结果： * Thread-0进入了同步代码块 * 停止线程前 * 停止线程后 * TIMED_WAITING * BLOCKED */
    }

lock的可中断和不可中断  
不可中断

public class Demo { 
        private static Lock lock = new ReentrantLock();
    
        public static void main(String[] args) throws InterruptedException { 
            Runnable run = () -> { 
                try { 
                    lock.lock();
                    System.out.println(Thread.currentThread().getName() + "获得锁，进入锁执行");
                    Thread.sleep(88888);//先阻塞一会
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                } finally { 
                    lock.unlock();
                }
            };
            Thread t1 = new Thread(run);
            t1.start();
            Thread.sleep(1000);
            Thread t2 = new Thread(run);
            t2.start();
            System.out.println("停止t2线程前");
            t2.interrupt();//强行停止，但lock.lock()中断不了, lock.tryLock()得不到锁是可以中断的
            System.out.println("停止t2线程后");
            Thread.sleep(1000);
            System.out.println(t1.getState());
            System.out.println(t2.getState());
        }
        /** * 执行结果 * Thread-0获得锁，进入锁执行 * 停止t2线程前 * 停止t2线程后 * TIMED_WAITING * WAITING */
    }

可中断

public class Demo { 
        private static Lock lock = new ReentrantLock();
    
        public static void main(String[] args) throws InterruptedException { 
            Runnable run = () -> { 
                boolean b=false;
                try { 
                  b=  lock.tryLock(3, TimeUnit.SECONDS);
                  if (b){ 
                      System.out.println(Thread.currentThread().getName() + "获得锁，进入锁执行");
                      Thread.sleep(88888);//先阻塞一会
                  }else { 
                      System.out.println(Thread.currentThread().getName() + "指定时间内没有得到锁，自动中断去做其他操作");
                  }
    
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                } finally { 
                    if (b){ 
                        lock.unlock();
                        System.out.println("释放锁");
                    }
                }
            };
            Thread t1 = new Thread(run);
            t1.start();
            Thread.sleep(1000);
            Thread t2 = new Thread(run);
            t2.start();
        }
    	/** * Thread-0获得锁，进入锁执行 * Thread-1指定时间内没有得到锁，自动中断去做其他操作 */
    }

先反汇编代码看一下：

public class SyncPrinciple { 
        private static Object obj=new Object();
    
        public static void main(String[] args) { 
            synchronized (obj){ 
                System.out.println("1");
            }
        }
        public synchronized void  test(){ 
            System.out.println("a");
        }
    }

# synchronized原理剖析 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 9]  
注意在21处也有monitorexit：当同步代码块出现异常，jvm会自动释放锁

1.能执行 monitorexit指令的线程一定是拥有当前对象的 monitor的所有权的线程

2.执行 monitore时会将 monitor的进入数减1,当 monitor的进入数减为0时,当前线程退出 monitor,不再拥有 monitor的所有权,此时其他被这个 monitor阻塞的线程可以尝试去获取这个 monitor的所有权

monitorexil释放锁

monitore插入在方法结束处和异常处,jvM保证每个 monitorenter必须有对应的 monitorexit

每一个对象都会和一个监视器monitor 关联,监视器被占用时会被锁住,其他线程无法来获取该monitor .当jvM执行某个线程的某个方法内部的monitorentor 时,它会尝试去获取当前对象对应的monitorentor 的所有权,其过程如下:

1.若monior 的进入数为0,线程可以进入monitor .,并将monitor的进入数置为1.当线程成为monitor 的owner 所有者

2.若线程已拥有monitore 的所有权,允许它重入monitor ,则进入monitore 的进入数加1

3.若其他线程已经占有monitors 的所有权,那么当前尝试获取monitor 的所有权的线程会被阻塞,直到monitor 的进入数变为0,才能重新尝试获取monitor 的所有权

monitorenter 小结

synchronized 的对象会关联个monitor 这个monitor 不是我们主动创建的，是jvM的线程执行到这个同步代码块，发现锁对象没有monitors 就会创建monitor ,monitor 内部有两个重要的成员变量owners （拥有这把锁的线程）recursions （会记录线程拥有锁的次数）当一个线程拥有monitor 后，其他线程只能等待  
【monitors 他是c++对象】  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 11]  
可以看到同步方法在反汇编后,会增加 ACC SYNCHRONIZED修饰。会隐式调用 monitorenter和monitorexit,在执行同步方法前会调用 monitorenter,在执行完同步方法后会调用 monitorexit

小结

通过avap反汇编我们看到 synchronized使用编程了 monitorentor和两个指令每个锁对象都会关联一个 monitor监视器它才是真正的锁对象它内部有两个重要的成员变量 owner会保存获得的钱程 recursions（递归计数？）会保存线程获得锁的次数当执行到 monitorexit时 recursions会-1,当计数器减到0时这个线程就会释放锁

# 面试题: synchronized与Lock的区别 #

1.  synchronized是关键字,而Lock是一个接口
2.  synchronized会自动释放锁,而Lock必须手动释放锁
3.  synchronized是不可中断的,LOck可以中断也可以不中断
4.  通过Lock可以知道线程有没有拿到锁,而 synchronized不能
5.  synchronized能锁住方法和代码块,而Lock只能锁住代码块(只能放在方法里面，不能放在方法上)
6.  Lock（主要是ReentrantReadWriteLock–它允许多个线程读数据）可以使用读锁提高多线程读效率
7.  synchronized是非公平锁，reentrantLock可以控制是否是公平锁  
    ![在这里插入图片描述][20200118123334675.png]

# synchronized的偏向锁模式 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 12]

如果启动了偏向锁（可在jvm启动参数中设置），就执行快进入  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 13]

Atomic系统内核函数，通过cpu去做这样一个原子操作。把monitor里面的owner设为当前线程  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 14]

![在这里插入图片描述][20200118183405334.png]  
![在这里插入图片描述][20200118183447735.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 15]

虽然没有抢到锁，但还是会trylock尝试一下

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 16]  
trylock代码如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 17]  
然后tryspin自旋：循环，多次来抢这个锁（再抢救一下）  
![在这里插入图片描述][20200118185033845.png]

如果还不行，就把它封装成一个等待的线程，并将状态设置成TS\_CXQ  
![在这里插入图片描述][20200118185120238.png]

会通过内核函数Atomic::cmpxchg\_ptr将wait的线程都挂到cxq节点上（它是一个链表），并且还会进行trylock抢救一下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 18]  
然后会将线程挂起，挂起后只有唤醒才能被执行  
![在这里插入图片描述][20200118185841248.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 19]

![在这里插入图片描述][20200118185141563.png]

w是要被唤醒的线程  
如果为2，则为cxq的链表头，即头节点给w（包装的将被唤醒的线程）

monitor释放锁的过程  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 20]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 21]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 22]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 23]  
被唤醒的线程会回到void ATTR objectMonitor：：EnterI(TRAPS)的 第600行，继续执行monitor的竞争  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 24]

monitor是重量级的锁，它调用了内核函数，这就导致内核态和用户态（用户空间：我们编写代码的那块空间）之间的频繁切换（需要通过系统调用来实现）。我们知道，这个切换是很消耗性能的

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 25]

可以看到 ObjectMonitor的函数调用中会涉及到 Atomic: cmpxchg\_ptr,\_ptrt等内核函数,执行同步代码块,没有竟争到锁的对象会park0被挂起,竟争到的线程会 unpark0唤醒,这个时候就会存在操作系统用户态和内核态的转换,这种切换会消耗大量的系统资源。所以 synchronized是Java语言中是一个重量级（Heavyweight）的操作,

--------------------

用户态和和内核态是什么东西呢?要想了解用户态和内核态还需要先了解一下 Linux系统的体系架构

从上图可以看出,操作系统的体系架构分为:用户空间(应用程序的活动空间)和内核

内核:本质上可以理解为一种软件,控制计算机的硬件资源,并提供上层应用程序运行的环境【内核是控制硬件资源（网络，键盘，鼠标）的应用程序】

用户空间:上层应用程序活动的空间。应用程序的执行必须依托于内核提供的资源,包括CPU资源、存储资源，1/O资源等

系统调用:为了使上层应用能够访问到这些资源,内核必须为上层应用提供访问的接口:即系统调用

所有进程初始都运行于用户空间,此时即为用户运行状态(简称:用户态):但是当它调用系统调用执行某些操作时,例如IO调用,此时需要陷入内核中运行,我们就称进程处于内核运行态(或简称为内核态),系统调用的过程可以简单理解为：

1.  用户态程序将一些数据值放在寄存器中,或者使用参数创建一个堆栈,以此表明需要操作系统提供的服务
2.  用户态程序执行系统调用
3.  CPU切换到内核态,并跳到位于内存指定位置的指令
4.  系统调用处理器 system call handler)会读取程序放入内存的数据参数,并执行程序请求的服务
5.  系统调用完成后,操作系统会重置CPU为用户态并返回系统调用的结果

由此可见用户态切换至内核态需要传递许多变量,同时内核还需要保护好用户态在切换时的一些寄存器值、变量等,以备内核态切换回用户态。这种切换就带来了大量的系统资源消耗,这就是在 synchronized末优化之前,效率低的原因

jdk6对synchronized的优化

java没有指针所以它不能直接操作内存地址

public class App
    { 
        /** *1. 定义共享变量number * 2.对number进行1000次的++操作 * 3.使用5个线程来进行 */
        public static AtomicInteger number=new AtomicInteger();
        public static void main( String[] args ) throws InterruptedException { 
            /** * 2.创建一个线程不断地去读共享变量 */
            Runnable increment=()->{ 
                for (int i=0;i<1000;i++){ 
                    number.incrementAndGet();
                }
            };
            List<Thread> list=new ArrayList<>();
            //使用5个线程来操作
            for (int i=0;i<5;i++){ 
                Thread t=new Thread(increment);
                t.start();
                list.add(t);
            }
            for (Thread t:list){ 
                //join的作用：保证5个线程都执行完，才打印共享变量number的值,他还可以保证线程按顺序执行
                t.join();
                //至于这里是没new一个Thread，然后add，而非a.join(b.join(c))
            }
            System.out.println("number:"+number.get());
        }
    }

Unsafe类提供了cas操作

# CAS概述和作用 #

cas的全成是:Compare And Swap (比较相同再交换),是现代CPu广泛支持的一种对内存中的共享数据进行操作的一种特殊指令

cas的作用:cas可以将比较和交换转换为原子操作,这个原子操作直接由CPU保证CAS可以保证共享变量赋值时的原子操作CAS操作依赖3个值:内存中的值V,旧的预估值X,要修改的新值B,如果旧的预估值X等于内存中的值,就将新的值保存到内存中

CAS+volitile可以实现无锁并发----它是乐观锁，适用于竞争不激烈，多核cpu的场景  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 26]  
cas执行过程如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 27]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 28]

> cas算法  
> 线程1和线程2都想修改共享变量x的值(都想对他进行++操作)。那同一时刻，他们都会去读取这个变量x的值，比方说读出来是0，那么就把这个0呢作为旧的预估值，假设线程1抢先执行了++操作，那么要更新的值就是1，在替换之前呢，他会再去读一下这个内存中的值，作为最新值，发现读出来是0，即内存中的最新值与旧的预估值相同(说明当前除了自己没有别的线程，在操作这个变量)，那么就更新这个值为1，此时线程2，也完成了++操作，他再去读一下内存中的最新值，发现是1(这是通过volatile关键字来实现的可见性)，和预估值0不相同，那么线程2会放弃本次的本次更新操作。然后它会再进行一次cas算法，读取内存中的值1作为旧的预估值，然后进行++操作，要更新的值就变为了2，在替换的时候他会再去，读一下内存中的最新值，发现是1…和旧的预估值相同，所以他会将内存中的1替换为2

锁升级  
刚开始会采用无锁，如果竞争过于激烈，无锁扛不住了，就转为偏向锁，然后是轻量锁，再是适应性自旋，然后才是重量锁

# java对象布局 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 29]

对齐填充是方便jvm寻址的

关闭指针压缩的jvm的参数设置：-XX:-UseCompressdOops  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 30]  
开启指针压缩

public class Demo { 
        public static void main(String[] args) { 
            LockObj obj=new LockObj();
            obj.hashCode();//需要调hash函数才会有hashcode在markword里面
            System.out.println(obj.hashCode());
            System.out.println(Integer.toHexString(obj.hashCode()));//打印它的10进制
            System.out.println(ClassLayout.parseInstance(obj).toPrintable());
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 31]

java对象的布局：对象头（标记字+类指针）+实例数据+对齐填充  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 32]  
klass pointer

这一部分用于存储对象的类型指针,该指针指向它的类元数据,JVM通过这个指针确定对象是哪个类的实例。该指针的位长度为jVM的一个字大小,即32位的jVM为32位,64位的jVM为64位

如果应用的对象过多,使用64位的指针将浪费大量内存,统计而言,64位的VM将会比32位的JVM多耗费50%的内存为了节约内存可以使用选项-xx:+UseCompressedoops 开启指针压缩,其中,oop即ordinary object普通对象指针，开启后，下列指针将压缩至32位

1.每个Class 的属性指针(即静态变量

2.每个对象的属性指针(即对象变量)

3.普通对象数组的每个元素指针

当然,也不是所有的指针都会压缩,一些特殊类型的指针VM不会优化，比如permGen的class对象指针(JDK8中指向元空间的Class 对象指针)、本地变量、堆栈元素、入参、返回值和null指针等

对象头=MarlWord +类型指针(未开启指针压缩的情况下)

在32位系统中,Mark Word =4bytes ,类型指针=4bytes ,对象头=8bytes =64bits

在64位系统中,Mark Word =8bytes ,类型指针=8Bbytes ,对象头=16bytes =128bits;

反复同一线程进入同一同步代码块，就比较适合用偏向锁。一旦有线程来竞争，就要撤销偏向锁，改为轻量级锁

测试代码：

public class Demo { 
        public static void main(String[] args) { 
           new MyThread().start();
          // new MyThread().start(); //多线程竞争下:锁升级成轻量锁---010
        }
    }
    class MyThread extends Thread{ 
        static Object obj=new Object();
    
        @Override
        public void run() { 
            for (int i=0;i<5;i++){ 
                synchronized (obj){ 
                    System.out.println(ClassLayout.parseInstance(obj).toPrintable());
                }
            }
        }
    }

设置jvm启动参数：-XX:BiasedLockingStartupDelay=0  
![在这里插入图片描述][20200118225303651.png]  
只需对比一下线程id是否相同就ok了。如果是在激烈竞争下使用偏向锁，并发相当于退化成了完全串行化执行了，即失去了并发的味道  
一旦多线程，就会撤销偏向锁

统计菜市场10点钟有多少人。办法是：10点钟时让所有人停下来，不让任何人再进出菜市场。所有线程停下来即全局安全点  
[参考][Link 1]

#  偏 向 锁 的 原 理 \\color\{red\}\{偏向锁的原理\} 偏向锁的原理 #

> 当锁对象第一次被线程获取的时候，虚拟机将会把对象头中的标志设为01，即偏向模式，同时使用cas操作，把获取到这个锁的线程的id记录在对象的mark word之中，如果cas操作成功，持有偏向锁的线程，以后每次进入这个锁相关的同步代码块时，虚拟机都可以不再进行任何同步操作，偏向锁的效率高。(这样就只需比较一次就好了)【对像头里面的锁状态 不同，则执行同步的操作也是不一样的】

偏向锁的好处是什么？  
偏向锁是在只有一个线程执行同步块时，进一步提高性能，适用于同一个线程，反复获得同一锁的情况，偏向锁，可以提高带有同步，但无竞争的程序性能

偏向锁的撤销  
1.偏向锁的撤销动作，必须等待全局安全点，  
2.暂停拥有偏向锁的线程，判断锁对象是否处于被锁定状态，  
3.撤销偏向锁，恢复到无锁标志位为01或轻量级锁标志为00的状态

偏向锁，是在只有一个线程执行同步代码块时进一步提高性能，适用于一个线程，反复获得同一锁的情况，偏向锁可以提高，带有同步，但无竞争的程序性能，他同样是一个带有效益权衡性质的优化，也就是说，他并不一定总是对程序运行有利，如果程序中大多数锁总是被多个不同的线程访问，比如线程池，那偏向模式就是多余的  
一旦出现多个线程竞争时，必须撤销偏向锁，所以撤销偏向锁消耗的性能必须小于之前节省下来的cas原子操作的性能消耗，不然就得不偿失了

多线程交替执行同步代码块时，比较适合用轻量级锁，当多线程在同一时刻进入临界区，此时就该撤销轻量级锁，该成重量级锁性能更好。jdk1.6之前，synchronized在什么场景下使用的都是重量级锁，比较笨重，死板，故性能较低。jdk1.6后synchronized则会根据不同的场景切换到响应的锁模式去优化性能

# 轻量级锁 #

当关闭偏向锁功能或者多个线程竞争偏向锁导致偏向锁升级为轻量级锁,则会尝试获取轻量级锁,其步骤如下:获取锁  
锁记录【mark word的拷贝】里面有（替换hdr【里面存的是分代年龄，hashcode，锁标志位】和owner）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 33]  
轻量锁模式的执行过程如下【//即mark word的锁标志已经是轻量锁00的情况下？】：

1.  判断当前对象是否处于无锁状态(hashcode 、0、01),如果是,则jVM首先将在当前线程的栈帧中建立一个名为锁记录(Lock Record )的空间,用于存储锁对象目前的Mark Word 的拷贝(官方把这份拷贝加了一个Displaced 前缀,即Displaced Mark Word ),将对象的Mark Word 复制到帧中的Lock Record 中,将LockReocrd 中的owner 指向当前对象
2.  jvm利用CAS操作尝试将对象的Mark Word 更新为指向Lock Record 的指针,如果成功表示竞争到锁,则将锁标志位变成00，执行同步操作
3.  如果失败，则判断当前对象的mark word是否指向当前线程的栈帧，如果是，则表示，当前线程已经持有当前对象的锁，就直接执行同步代码块，否则只能说明该锁对象已经被其他线程抢占了，这时轻量级锁需要膨胀为重量级锁，锁标志，变为10，后面等待的线程将会进入阻塞状态

**轻量级锁的释放**

轻量级锁的释放也是通过CAS操作来进行的,主要步骤如下:

1.取出在获取轻量级锁保存在Displaced Mark Word 中的数据。

2.用CAS操作将取出的数据替换当前对象的Mark Word 中,如果成功,则说明释放锁成功。

3.如果CAS操作替换失败,说明有其他线程尝试获取该锁,则需要将轻量级锁需要膨胀升级为重量级锁。

对于轻量级锁,其性能提升的依据是“对于绝大部分的锁,在整个生命周期内都是不会存在竞争的”,如果打破这个依据则除了互斥的开销外,还有额外的CAS操作,因此在有多线程竞争的情况下,轻量级锁比重量级锁更慢。

轻量级锁好处

在多线程交替执行同步块的情况下,可以避免重量级锁引起的性能消耗。（轻量级锁：  
餐厅里只有一把椅子，但十个人大家都想坐，如果是每隔两秒钟进来一个人，且每个人都只坐凳子两秒钟，这样交替轮流的场景就比较适合用轻量级锁，但如果只十个人，是同一时刻进来的，那么再用轻量级锁就不合适了  
）

小结

轻量级锁的原理是什么?

将对象的Mark Word 复制到栈帧中的Lock Recod 中。Mark Word 更新为指向Lock Record 的指针

轻量级锁好处是什么?

在多线程交替执行同步块的情况下,可以避免重量级锁引起的性能消耗。

#  自 旋 锁 \\color\{red\}\{自旋锁\} 自旋锁 #

> 自旋锁：是让没有抢到锁的线程不阻塞，而是让它循环几次来抢锁。（当尝试次数超过阈值才让它进入阻塞）多核cpu可以做到：一个线程在里面执行同步代码块，另一个线程在外面循环等待，并尝试获得锁【通过执行一个忙循环】

执行同步代码块的时间其实很短，那么短的一点时间，做一下自旋就好了，不必使其进行内核态和用户态的切换

两个线程枪锁，一个没抢到，重量级锁是让他进入阻塞，随后在唤醒它，这样会很好性能，你还没进入阻塞 ，可能那个线程就已经执行完同步代码块了。所以较好的办法就是让它多尝试几次获取锁就好了，再多挣扎一下【a上厕所需要十秒的时间，b从位置走到厕所需要30秒的时间，现在a进入了厕所，锁上了门，重量级锁的做法，b来上厕所，发现有人，然后花了30秒的时间回去，之后再花了30秒的时间走到厕所，然后开始上厕所，自旋锁是花了30秒时间来到了厕所旁，发现厕所有人，先等待十秒钟，并且每隔一秒就敲一下门，询问里面的人的情况，尝试获得上厕所的资源  
】

没抢到锁，会进入enterI，挂起线程

阻塞之前会尝试获得锁，失败则进入自旋

得不到锁，就稍微花点时间等待一下，  
如果刚刚自旋成功获取了锁，那么会认为下次也会自旋获得锁，所以自旋时间会增加。  
没抢到锁就进入自旋等待  
默认是尝试10次自旋  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 34]

自旋锁  
前面我们讨论monitor 实现锁的时候,知道monitor 会阻塞和唤醒线程,线程的阻塞和唤醒需要CPU从用户态转为核心态,频繁的阻塞和唤醒对CPU来说是一件负担很重的工作,这些操作给系统的并发性能带来了很大的压力。同时,虚拟机的开发团队也注意到在许多应用上,共享数据的锁定状态只会持续很短的一段时间,为了这段时间阻塞和唤醒线程并不值得。如果物理机器有一个以上的处理器,能让两个或以上的线程同时并行执行,我们就可以让后面请求锁的那个线程等一下”,但不放弃处理器的执行时间,看看持有锁的线程是否很快就会释放锁。为了让线程等待,我们只需让线程执行一个忙循环(自旋)这项技术就是所谓的自旋锁

自旋锁在DK1.4.2中就已经引入,只不过默认是关闭的,可以使用-xx+UseSpinning 参数来开启,在DK6中就已经改为默认开启了。自旋等待不能代替阻塞,且先不说对处理数量的要求,自旋等待本身虽然避免了线程切换的开销,但它是要占用处理器时间的,因此,如果锁被占用的时间很短,自旋等待的效果就会非常好,反之,如果锁被占用的时间很长。那么自旋的线程只会白白耗处理器资源,而不会做任何有用的工作,反而会带来性能上的浪费。因此,自旋等待的时间必须要有一定的限度,如果自旋超过了限定的次数仍然没有成功获得锁,就当使用传统的方式去挂起线程了,自旋次数的默认值是10次,用户可以使用参数-xx:PreBlockSpin 来更改。

适应性自旋锁

在DK6中引入了自适应的自旋锁。自适应意味着自旋的时间不再固定了,而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。如果在同一个锁对象上,自旋等待刚刚成功获得过锁,并且持有锁的线程正在运行中,那么虚拟机就会认为这次自旋也很有可能再次成功,进而它将允许自旋等待持续相对更长的时间,比如100次循环。另外,如果对于某个锁,自旋很少成功获得过,那在以后要获取这个锁时将可能省略掉自旋过程,以避免浪费处理器资源,有了自适应自旋,随着程序运行和性能监控信息的不断完善,虚拟机对程序锁的状况预测就会越来越准确,虚拟机就会变得越来越聪明了。

# 锁消除 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 35]  
对象逃逸不出方法，则就不会存在竞争，所以也就不需要锁。这样的场景可以进行锁消除  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 36]

同步代码块里面的代码应执行时间尽量短，代码尽量少，这样偏向，轻量，自旋 都能满足要求，可避免锁升级成重量级锁

# 锁粗化 #

进出同步代码块100次  
将小锁变成大锁，原来是进出100次，现在只需进出1次就可以搞定了。将零散的锁合成一把大锁  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 37]  
代码测试如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 38]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 39]

# 锁优化 #

读写分离，读的时候不加锁，写的时候才加锁

降低锁的粒度，能用对象锁的就不要用类锁

一把锁去读，一把锁去写

concurrenthashmap在没有元素的时候会使用cas，有元素时是对一个桶加锁  
hashtable是对crud整个方法都加了锁，所以读写不分离  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 40]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 41]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 42]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 43]

[参考][Link 2]

相关依赖：

<dependency>
          <groupId>org.openjdk.jol</groupId>
          <artifactId>jol-core</artifactId>
          <version>0.9</version>
        </dependency>
        
        <dependency>
          <groupId>org.openjdk.jcstress</groupId>
          <artifactId>jcstress-core</artifactId>
          <version>0.5</version>
        </dependency>

规范：肤白貌美大长腿  
实现：貂蝉，西施…

[20200117152213742.png]: https://img-blog.csdnimg.cn/20200117152213742.png
[join]: https://www.cnblogs.com/lyuweigh/p/9568697.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200117155432919.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200117160301431.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[20200117203226768.png]: https://img-blog.csdnimg.cn/20200117203226768.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200117234621776.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200117235751232.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200118001012914.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200118003915238.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200118010223818.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200118012304781.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200118012718691.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200118112341549.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200118112027426.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20200118113552157.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[20200118123334675.png]: https://img-blog.csdnimg.cn/20200118123334675.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20200118145927233.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20200118150307787.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/20200118175012322.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[20200118183405334.png]: https://img-blog.csdnimg.cn/20200118183405334.png
[20200118183447735.png]: https://img-blog.csdnimg.cn/20200118183447735.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/20200118183605209.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 16]: https://img-blog.csdnimg.cn/20200118185017730.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 17]: https://img-blog.csdnimg.cn/20200118185237915.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[20200118185033845.png]: https://img-blog.csdnimg.cn/20200118185033845.png
[20200118185120238.png]: https://img-blog.csdnimg.cn/20200118185120238.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 18]: https://img-blog.csdnimg.cn/20200118185635356.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[20200118185841248.png]: https://img-blog.csdnimg.cn/20200118185841248.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 19]: https://img-blog.csdnimg.cn/20200118185310927.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[20200118185141563.png]: https://img-blog.csdnimg.cn/20200118185141563.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 20]: https://img-blog.csdnimg.cn/20200118191001567.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 21]: https://img-blog.csdnimg.cn/20200118191152214.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 22]: https://img-blog.csdnimg.cn/20200118191210416.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 23]: https://img-blog.csdnimg.cn/20200118191506712.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 24]: https://img-blog.csdnimg.cn/20200118191805225.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 25]: https://img-blog.csdnimg.cn/20200118193317860.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 26]: https://img-blog.csdnimg.cn/20200118202818504.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 27]: https://img-blog.csdnimg.cn/20200118203658352.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 28]: https://img-blog.csdnimg.cn/20200118203711723.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 29]: https://img-blog.csdnimg.cn/20200118203605990.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 30]: https://img-blog.csdnimg.cn/20200118205142679.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 31]: https://img-blog.csdnimg.cn/20200118221949449.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 32]: https://img-blog.csdnimg.cn/20200118222410652.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[20200118225303651.png]: https://img-blog.csdnimg.cn/20200118225303651.png
[Link 1]: http://www.sohu.com/a/330911617_120210224
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 33]: https://img-blog.csdnimg.cn/20200118235927759.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 34]: https://img-blog.csdnimg.cn/2020011900393898.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 35]: https://img-blog.csdnimg.cn/20200119005550422.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 36]: https://img-blog.csdnimg.cn/202001190053557.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 37]: https://img-blog.csdnimg.cn/20200119010420520.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 38]: https://img-blog.csdnimg.cn/20200119010358173.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 39]: https://img-blog.csdnimg.cn/20200119010445876.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 40]: https://img-blog.csdnimg.cn/20200119011730593.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 41]: https://img-blog.csdnimg.cn/20200119011810976.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 42]: https://img-blog.csdnimg.cn/20200119011830884.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 43]: https://img-blog.csdnimg.cn/20200119011856250.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[Link 2]: https://www.jianshu.com/p/48c9ef72fe52