java程序员应该掌握的底层知识

ゞ浴缸里的玫瑰 2023-02-14 07:50 90阅读 0赞

### 文章目录 ###

*  java程序员应该掌握的底层知识
 *   *  相关书籍推荐
     *  硬件基础知识
     *   *  CPU的制作过程
         *  CPU的原理
         *  计算机组成
         *  汇编语言（机器语言）的执行过程
         *  量子计算机
         *  cpu的基础组成
         *  存储器的层次结构
         *  缓存
         *  cpu的乱序执行
         *  合并写
         *  UMA与NUMA
     *  操作系统基本知识
     *   *  启动
         *  什么是操作系统
         *  内核分类
         *  用户态与内核态
     *  进程 线程 纤程的基本概念（面试高频）
     *   *  纤程
         *  纤程的实现
         *  纤程的应用场景
         *  内核线程
         *  进程的创建和启动
         *  僵尸进程
         *  孤儿进程
         *  进程调度
     *  中断与系统调用（软中断）
     *   *  从汇编角度理解软中断
 *  内存管理
 *   *  内存管理的发展历程
     *  ZGC
     *  CPU如何区分一个立即数 和 一条指令
 *  内核同步机制
 *   *  关于同步理论的一些基本概念
     *  内核同步常用方法
 *  汇编实现引导程序
 *   *  编写汇编码
     *  编译
     *  制作启动软盘
     *  用软盘启动系统
     *  为什么是0x7C00?

# java程序员应该掌握的底层知识 #

## 相关书籍推荐 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center]  
读书原则：不求甚解，观其大略。

## 硬件基础知识 ##

关于底层的实现细节：适度打开

很多情况下保持黑箱即可，因为打开这个黑箱，你就会发现黑箱会变成黑洞，吞噬你所有的时间和精力，有可能使你偏离原来的方向，陷入到不必要的细节中无法自拔。

### CPU的制作过程 ###

本质：一堆沙子 + 一堆铜 + 一堆胶水 + 特定金属添加 + 特殊工艺

沙子脱氧 ->石英 ->二氧化硅 ->提纯 ->硅锭 -> 切割->晶圆 -> 涂抹光刻胶-> 光刻-> 蚀刻->清除光刻胶 ->电镀 -> 抛光-> 铜层-> 测试->切片 ->封装

Intel cpu的制作过程(视频描述)

[https://haokan.baidu.com/v?vid=11928468945249380709&pd=bjh&fr=bjhauthor&type=video][https_haokan.baidu.com_v_vid_11928468945249380709_pd_bjh_fr_bjhauthor_type_video]

cpu是如何制作的(文字描述)

[https://www.sohu.com/a/255397866\_468626][https_www.sohu.com_a_255397866_468626]

cpu内部：硅-> 加入特殊元素->P半导体 N半导体 -> PN结->二极管 ->场效应晶体管 -> 逻辑开关

基础逻辑电路：与门 或门 非门 或非门（异或） 加法器 累加器 锁存器 、、、

实现手动计算(每次读取内存指令，(高电低电))

推荐书籍：《编码》17章

对于cpu运算是通过高电频，低电频->转换成逻辑上，就为二进制数字：0，1->告诉计算机哪个针脚该通断电

手工输入：纸带计算机

助记符：01000010->mov sub……

高级语言->编译器->机器语言

### CPU的原理 ###

计算机需要解决的最根本问题：如何代表数字

晶体管是如何工作的：

[https://haokan.baidu.com/v?vid=16026741635006191272&pd=bjh&fr=bjhauthor&type=][https_haokan.baidu.com_v_vid_16026741635006191272_pd_bjh_fr_bjhauthor_type][video][https_haokan.baidu.com_v_vid_16026741635006191272_pd_bjh_fr_bjhauthor_type]

晶体管的工作原理：

https://www.bilibili.com/video/av47388949?p=2

### 计算机组成 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 1]  
内存和cpu是计算机的核心

### 汇编语言（机器语言）的执行过程 ###

汇编的本质：助记符 mov sub add代表二进制数据

过程：计算机通电 -> CPU读取内存中程序（电信号输入）->时钟发生器不断震荡通断电 ->推动CPU内部一步一步执行（执行多少步取决于指令需要的时钟周期）->计算完成->写回（电信号）->写给显卡输出（sout，或者图形）

### 量子计算机 ###

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

### cpu的基础组成 ###

PC -> Program Counter 程序计数器 （记录当前指令地址）

Registers -> 暂时存储CPU计算需要用到的数据

ALU -> Arithmetic & Logic Unit 运算单元

CU -> Control Unit 控制单元 中断信号的控制

MMU -> Memory Management Unit 内存管理单元–硬件+os实现

超线程：一个ALU对应多个PC|Register

所谓的四核八线程  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 2]

### 存储器的层次结构 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 4]  
缓存最基本原理：程序局部性原理，可以提高效率。

充分发挥总线CPU针脚等一次性读取更多数据的能力。

### 缓存 ###

一致性协议：https://www.cnblogs.com/z00377750/p/9180644.html  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 4]

缓存行：目前工业上来说三级缓存最合适

缓存行越大，局部性空间效率越高，但读取时间慢  
缓存行越小，局部性空间效率越低，但读取时间快

取一个折中值，目前多用：64字节

同一缓存行1亿次赋值执行效率 volatile保证线程之间的可见性

package com.mashibing.juc.c_028_FalseSharing;
    
    public class T03_CacheLinePadding { 
    
        public static volatile long[] arr = new long[2];
    
        public static void main(String[] args) throws Exception { 
            Thread t1 = new Thread(()->{ 
                for (long i = 0; i < 10000_0000L; i++) { 
                    arr[0] = i;
                }
            });
    
            Thread t2 = new Thread(()->{ 
                for (long i = 0; i < 10000_0000L; i++) { 
                    arr[1] = i;
                }
            });
    
            final long start = System.nanoTime();
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println((System.nanoTime() - start)/100_0000);
        }
    }

不同缓存行1亿次赋值执行效率

package com.mashibing.juc.c_028_FalseSharing;
    
    public class T04_CacheLinePadding { 
    
        public static volatile long[] arr = new long[16];
    
        public static void main(String[] args) throws Exception { 
            Thread t1 = new Thread(()->{ 
                for (long i = 0; i < 10000_0000L; i++) { 
                    arr[0] = i;
                }
            });
    
            Thread t2 = new Thread(()->{ 
                for (long i = 0; i < 10000_0000L; i++) { 
                    arr[8] = i;
                }
            });
    
            final long start = System.nanoTime();
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println((System.nanoTime() - start)/100_0000);
        }
    }

缓存行对齐：对于有些特别敏感的数字，会存在线程高竞争的访问。为了保证不发生伪共享，可以使用缓存行对齐的编程方式。

JDK7中，很多采用long padding提高效率  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 5]

JDK8，加入了@Contended注解（实验）需要加上：JVM -XX:-RestrictContended

package com.mashibing.juc.c_028_FalseSharing;
    
    import sun.misc.Contended;
    
    /** * T05_Contended * Description * * @date 2020/5/26 - 23:38 */
    
    public class T05_Contended { 
        @Contended
        volatile long x;
        @Contended
        volatile long y;
    
        public static void main(String[] args) throws InterruptedException { 
            T05_Contended t = new T05_Contended();
            Thread t1 = new Thread(()->{ 
               for (long i=0;i<1_0000_0000L;i++){ 
                   t.x=i;
               }
            });
    
            Thread t2 = new Thread(()->{ 
                for (long i=0;i<1_0000_0000L;i++){ 
                    t.y=i;
                }
            });
    
            final long start = System.nanoTime();
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println((System.nanoTime() - start)/100_0000);
        }
    }

### cpu的乱序执行 ###

根源：cpu在读等待的同时执行指令（乱序不是乱，为了效率）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 6]  
乱序的证明：[https://preshing.com/20120515/memory-reordering-caught-in-the-act/][https_preshing.com_20120515_memory-reordering-caught-in-the-act]

package com.mashibing.jvm.c3_jmm;
    
    public class T04_Disorder { 
        private static int x = 0, y = 0;
        private static int a = 0, b =0;
    
        public static void main(String[] args) throws InterruptedException { 
            int i = 0;
            for(;;) { 
                i++;
                x = 0; y = 0;
                a = 0; b = 0;
                Thread one = new Thread(new Runnable() { 
                    public void run() { 
                        //由于线程one先启动，下面这句话让它等一等线程two. 读着可根据自己电脑的实际性能适当调整等待时间.
                        //shortWait(100000);
                        a = 1;
                        x = b;
                    }
                });
    
                Thread other = new Thread(new Runnable() { 
                    public void run() { 
                        b = 1;
                        y = a;
                    }
                });
                one.start();other.start();
                one.join();other.join();
                String result = "第" + i + "次 (" + x + "," + y + "）";
                if(x == 0 && y == 0) { 
                    System.err.println(result);
                    break;
                } else { 
                    //System.out.println(result);
                }
            }
        }
    
    
        public static void shortWait(long interval){ 
            long start = System.nanoTime();
            long end;
            do{ 
                end = System.nanoTime();
            }while(start + interval >= end);
        }
    }

乱序执行可能会出现问题（存在于多线程）->DCL为什么要volatile？->禁止指令重排序  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 9]

*  有序性保障
    
     *  X86 CPU内存屏障
    
    sfence：在sfence指令前的写操作必须在sfence指令后的写操作前完成
    
    Infence：在sfence指令前的读操作必须在sfence指令后的读操作前完成
    
    mfence：在mfence指令前的读写操作必须在mfence指令后的读写操作前完成
    
     *  intel lock汇编指令
    
    原子指令，如X86上的“lock……”指令是一个Full Barrier，执行时会锁住内存子系统来确保执行顺序，甚至跨多个CPU。
    
    SoftWare Locks通常使用了内存屏障或原子指令来实现变量可见性和保持程序顺序。
    
     *  JSR内存屏障
    
    LoadLoad屏障：
    
     对于这样的语句Load1，LoadLoad，Load2
    
     在Load2及后续读取操作要读取的数据被访问前，保证Load1要读取的数据被读取完毕。
    
    StoreStore屏障：
    
     对于这样的语句Store1，StoreStore，Store2
    
     在Store2及后续写入操作执行前，保证Store1的写入操作对其他处理器可见。
    
    LoadStore屏障：
    
     对于这样的语句Load1，LoadStore，Store2
    
     在Store2及后续写入操作被刷出前，保证Load1要读取的数据被读取完毕。
    
    StoreLoad屏障：
    
     对于这样的语句Store1，StoreLoad，Load2
    
     在load2及后续所有读取操作执行前，保证Store1的写入对所有处理器可见。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 10]

底层屏障由lock指令实现的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 11]

as if serial：不管如何重排序，单线程执行结果不会改变。

JVM层级：8个hanppens-before原则 4个内存屏障 （LL LS SL SS）

### 合并写 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 12]  
由于ALU速度太快，所以在写入L1的同时，写入一个WC Buffer，满了之后，再直接更新到L2。

package com.mashibing.juc.c_029_WriteCombining;
    
    public final class WriteCombining { 
    
        private static final int ITERATIONS = Integer.MAX_VALUE;
        private static final int ITEMS = 1 << 24;
        private static final int MASK = ITEMS - 1;
    
        private static final byte[] arrayA = new byte[ITEMS];
        private static final byte[] arrayB = new byte[ITEMS];
        private static final byte[] arrayC = new byte[ITEMS];
        private static final byte[] arrayD = new byte[ITEMS];
        private static final byte[] arrayE = new byte[ITEMS];
        private static final byte[] arrayF = new byte[ITEMS];
    
        public static void main(final String[] args) { 
    
            for (int i = 1; i <= 3; i++) { 
                System.out.println(i + " SingleLoop duration (ns) = " + runCaseOne());
                System.out.println(i + " SplitLoop duration (ns) = " + runCaseTwo());
            }
        }
    
        public static long runCaseOne() { 
            long start = System.nanoTime();
            int i = ITERATIONS;
    
            while (--i != 0) { 
                int slot = i & MASK;
                byte b = (byte) i;
                arrayA[slot] = b;
                arrayB[slot] = b;
                arrayC[slot] = b;
                arrayD[slot] = b;
                arrayE[slot] = b;
                arrayF[slot] = b;
            }
            return System.nanoTime() - start;
        }
    
        public static long runCaseTwo() { 
            long start = System.nanoTime();
            int i = ITERATIONS;
            while (--i != 0) { 
                int slot = i & MASK;
                byte b = (byte) i;
                arrayA[slot] = b;
                arrayB[slot] = b;
                arrayC[slot] = b;
            }
            i = ITERATIONS;
            while (--i != 0) { 
                int slot = i & MASK;
                byte b = (byte) i;
                arrayD[slot] = b;
                arrayE[slot] = b;
                arrayF[slot] = b;
            }
            return System.nanoTime() - start;
        }
    }

### UMA与NUMA ###

UMA（uniform memory access）：多个cpu对同一个内存进行访问。

缺点：不易拓展，CPU数量增多后会引起内存访问冲突加剧。CPU很多资源浪费在争夺内存地址上。4颗合适

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 13]

NUMA（non uniform memory access）：非统一访问内存。从主板上会将cpu与内存分为不同的槽  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 14]  
ZGC：NUMA Aware 分配内存会优先分配该线程所在CPU的最近内存

## 操作系统基本知识 ##

### 启动 ###

通电 -> bios uefi 工作 -> 自检 -> 到硬盘固定位置加载bootloader -> 读取可配置信息 -> CMOS

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 15]

### 什么是操作系统 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 7]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 8]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 16]

微内核：主要负责进程调度

### 内核分类 ###

微内核 - 弹性部署 5G IoT

宏内核 - PC phone

外核 - 科研 实验中 为应用定制操作系统 (多租户 request-based GC JVM)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 11]

### 用户态与内核态 ###

cpu分不同的指令级别

linux内核跑在ring 0级， 用户程序跑在ring 3，对于系统的关键访问，需要经过kernel的同意，保证系统健壮性

内核执行的操作 - > 200多个系统调用 sendfile read write pthread fork

JVM -> 站在OS老大的角度，就是个普通程序

## 进程 线程 纤程的基本概念（面试高频） ##

面试高频：进程和线程有什么区别？

进程就是一个程序运行起来的状态，线程是一个进程中的不同的执行路径。

专业：进程是OS分配资源的基本单位，线程是执行调度的基本单位。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 12]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 13]  
 分配资源最重要的是：分配内存空间。线程调度执行（线程共享进程的内存空间，没有自己独立的内存空间）

### 纤程 ###

用户态的线程，线程中的线程，切换和调度不需要经过OS

优势：1：占有资源很少 OS : 线程1M Fiber：4K 2：切换比较简单 3：启动很多个10W+

目前2020 3 22支持内置纤程的语言：Kotlin Scala Go Python(lib)… Java? （open jdk : loom）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 17]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 14]

### 纤程的实现 ###

Java中对于纤程的支持：没有内置，盼望内置

利用Quaser库（不成熟）

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>mashibing.com</groupId>
        <artifactId>HelloFiber</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <dependencies>
            
            <dependency>
                <groupId>co.paralleluniverse</groupId>
                <artifactId>quasar-core</artifactId>
                <version>0.8.0</version>
            </dependency>
        </dependencies>
    
    </project>

import co.paralleluniverse.fibers.Fiber;
    import co.paralleluniverse.fibers.SuspendExecution;
    import co.paralleluniverse.strands.SuspendableRunnable;
    
    public class HelloFiber { 
    
        public static void main(String[] args) throws  Exception { 
            long start = System.currentTimeMillis();
            Runnable r = new Runnable() { 
                @Override
                public void run() { 
                    calc();
                }
            };
    
            int size = 10000;
    
            Thread[] threads = new Thread[size];
            for (int i = 0; i < threads.length; i++) { 
                threads[i] = new Thread(r);
            }
    
            for (int i = 0; i < threads.length; i++) { 
                threads[i].start();
            }
    
            for (int i = 0; i < threads.length; i++) { 
                threads[i].join();
            }
    
            long end = System.currentTimeMillis();
            System.out.println(end - start);
    
    
        }
    
        static void calc() { 
            int result = 0;
            for (int m = 0; m < 10000; m++) { 
                for (int i = 0; i < 200; i++) result += i;
    
            }
        }
    }

import co.paralleluniverse.fibers.Fiber;
    import co.paralleluniverse.fibers.SuspendExecution;
    import co.paralleluniverse.strands.SuspendableRunnable;
    
    public class HelloFiber2 { 
    
        public static void main(String[] args) throws  Exception { 
            long start = System.currentTimeMillis();
    
    
            int size = 10000;
    
            Fiber<Void>[] fibers = new Fiber[size];
    
            for (int i = 0; i < fibers.length; i++) { 
                fibers[i] = new Fiber<Void>(new SuspendableRunnable() { 
                    public void run() throws SuspendExecution, InterruptedException { 
                        calc();
                    }
                });
            }
    
            for (int i = 0; i < fibers.length; i++) { 
                fibers[i].start();
            }
    
            for (int i = 0; i < fibers.length; i++) { 
                fibers[i].join();
            }
    
            long end = System.currentTimeMillis();
            System.out.println(end - start);
    
    
        }
    
        static void calc() { 
            int result = 0;
            for (int m = 0; m < 10000; m++) { 
                for (int i = 0; i < 200; i++) result += i;
    
            }
        }
    }

作业：目前是10000个Fiber -> 1个JVM线程，想办法提高效率，10000Fiber -> 10份 -> 10Threads

### 纤程的应用场景 ###

纤程 vs 线程池：很短的计算任务，不需要和内核打交道，并发量高！

### 内核线程 ###

内核在启动之后经常需要做一些后台操作，这些由Kernel Thread来完成，只在内核空间运行。

### 进程的创建和启动 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 15]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 16]

### 僵尸进程 ###

#include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <string.h>
    #include <assert.h>
    #include <sys/types.h>
    
    int main() { 
            pid_t pid = fork();
    
            if (0 == pid) { 
                    printf("child id is %d\n", getpid());
                    printf("parent id is %d\n", getppid());
            } else { 
                    while(1) { }
            }
    }

### 孤儿进程 ###

#include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <string.h>
    #include <assert.h>
    #include <sys/types.h>
    
    int main() { 
            pid_t pid = fork();
    
            if (0 == pid) { 
                    printf("child ppid is %d\n", getppid());
                    sleep(10);
                    printf("parent ppid is %d\n", getppid());
            } else { 
                    printf("parent id is %d\n", getpid());
                    sleep(5);
                    exit(0);
            }
    }

### 进程调度 ###

2.6采用CFS调度策略：Completely Fair Scheduler

按优先级分配时间片的比例，记录每个进程的执行时间，如果有一个进程执行时间不到他应该分配的比例，优先执行

默认调度策略：

实时 （急诊） 优先级分高低 - FIFO (First In First Out)，优先级一样 - RR（Round Robin） 普通： CFS

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 17]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 18]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 19]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 20]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 21]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 22]

## 中断与系统调用（软中断） ##

硬件跟操作系统内核打交道的一种机制

软中断（80中断） == 系统调用

系统调用：int 0x80 或者 sysenter原语

通过ax寄存器填入调用号

参数通过bx cx dx si di传入内核

返回值通过ax返回

java读网络 – jvm read() – c库read() - > 内核空间 -> system\_call() （系统调用处理程序）-> sys\_read()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 18]

### 从汇编角度理解软中断 ###

搭建汇编环境

yum install nasm

;hello.asm
    ;write(int fd, const void *buffer, size_t nbytes)
    ;fd 文件描述符 file descriptor - linux下一切皆文件
    
    section data
        msg db "Hello", 0xA
        len equ $ - msg
    
    section .text
    global _start
    _start:
    
        mov edx, len
        mov ecx, msg
        mov ebx, 1 ;文件描述符1 std_out
        mov eax, 4 ;write函数系统调用号 4
        int 0x80
    
        mov ebx, 0
        mov eax, 1 ;exit函数系统调用号
        int 0x80

编译：nasm -f elf hello.asm -o hello.o

链接：ld -m elf\_i386 -o hello hello.o

一个程序的执行过程，要么处于用户态，要么处于内核态

# 内存管理 #

## 内存管理的发展历程 ##

DOS时代 - 同一时间只能有一个进程在运行（也有一些特殊算法可以支持多进程）

windows9x - 多个进程装入内存 1：内存不够用 2：互相打扰

为了解决这两个问题，诞生了现在的内存管理系统：虚拟地址 分页装入 软硬件结合寻址

1.  分页（内存不够用），内存中分成固定大小的页框（4K），把程序（硬盘上）分成4K大小的块，用到哪一块，加载那一块，加载的过程中，如果内存已经满了，会把最不常用的一块放到swap分区， 把最新的一块加载进来，这个就是著名的LRU算法
    
    1.  LRU算法 LeetCode146题，头条要求手撕，阿里去年也要求手撕
    2.  Least Recently Used 最不常用
    3.  哈希表（保证 查找操作O(1)） + 链表 （保证 排序操作和新增操作 O(1)））
    4.  双向链表 （保证 左边指针 指向右边块）
2.  虚拟内存（解决相互打扰问题）
    
    1.  DOS Win31 … 互相干掉
    2.  为了保证互不影响 - 让进程工作在虚拟空间，程序中用到的空间地址不再是直接的物理地址，而是虚拟的地址，这样，A进程永远不可能访问到B进程的空间
    3.  虚拟空间多大呢？寻址空间 - 64位系统 2 ^ 64，比物理空间大很多 ，单位是byte
    4.  站在虚拟的角度，进程是独享整个系统 + CPU
    5.  内存映射：偏移量 + 段的基地址 = 线性地址 （虚拟空间）
    6.  线性地址通过 OS + MMU（硬件 Memory Management Unit）
3.  缺页中断（不是很重要）：
    
    1.  需要用到页面内存中没有，产生缺页异常（中断），由内核处理并加载

## ZGC ##

算法叫做：Colored Pointer

GC信息记录在指针上，不是记录在头部， immediate memory use

42位指针 寻址空间4T JDK13 -> 16T 目前为止最大16T 2^44

## CPU如何区分一个立即数 和 一条指令 ##

总线内部分为：数据总线 地址总线 控制总线

地址总线目前：48位

颜色指针本质上包含了地址映射的概念

# 内核同步机制 #

## 关于同步理论的一些基本概念 ##

•临界区（critical area）: 访问或操作共享数据的代码段 简单理解：synchronized大括号中部分（原子性）

•竞争条件（race conditions）两个线程同时拥有临界区的执行权

•数据不一致：data unconsistency 由竞争条件引起的数据破坏

•同步（synchronization）避免race conditions

•锁：完成同步的手段（门锁，门后是临界区，只允许一个线程存在） 上锁解锁必须具备原子性

•原子性（象原子一样不可分割的操作）

•有序性（禁止指令重排）

•可见性（一个线程内的修改，另一个线程可见）

互斥锁 排他锁 共享锁 分段锁

## 内核同步常用方法 ##

1.原子操作 – 内核中类似于AtomicXXX，位于<linux/types.h>

2.自旋锁 – 内核中通过汇编支持的cas，位于<asm/spinlock.h>

3.读-写自旋 – 类似于ReadWriteLock，可同时读，只能一个写 读的时候是共享锁，写的时候是排他锁

4.信号量 – 类似于Semaphore(PV操作 down up操作 占有和释放） 重量级锁，线程会进入wait，适合长时间持有的锁情况

5.读-写信号量 – downread upread downwrite upwrite （多个写，可以分段写，比较少用）(分段锁）

6.互斥体(mutex) – 特殊的信号量（二值信号量）

7.完成变量 – 特殊的信号量（A发出信号给B，B等待在完成变量上） vfork() 在子进程结束时通过完成变量叫醒父进程 类似于(Latch)

8.BKL：大内核锁（早期，现在已经不用）

9.顺序锁（2.6）： – 线程可以挂起的读写自旋锁 序列计数器（从0开始，写时增加(+1)，写完释放(+1)，读前发现单数， 说明有写线程，等待，读前读后序列一样，说明没有写线程打断）

10.禁止抢占 – preempt\_disable()

11.内存屏障 – 见volatile

# 汇编实现引导程序 #

## 编写汇编码 ##

; 文件名 boot.asm
     
    org 7c00h                     ; BIOS读入MBR后，从0x7c00h处开始执行
     
    ; 下面部分和10h有关中断，10h中断用来显示字符
    mov ax, cs
    mov es, ax
    mov ax, msg
    mov bp, ax                    ; ES:BP表示显示字符串的地址
    mov cx, msgLen                ; CX存字符长度
    mov ax, 1301h                 ; AH=13h表示向TTY显示字符，AL=01h表示显示方式（字符串是否包含显示属性，01h表示不包含）
    mov bx, 000fh                 ; BH=00h表示页号，BL=0fh表示颜色
    mov dl, 0                     ; 列
    int 10h
      
    msg: db "hello world, welcome to OS!"
    msgLen: equ $ - msg           ; 字符串长度
    times 510 - ($ - $$) db 0     ; 填充剩余部分
    dw 0aa55h                     ; 魔数，必须有这两个字节BIOS才确认是MBR

## 编译 ##

nasm boot.asm -o boot.bin

## 制作启动软盘 ##

1.  dd if=/dev/zero of=floppy.img bs=1474560 count=1 **生成空白软盘镜像**
2.  dd if=boot.bin of=myos.img bs=512 count=1 **制作包含主引导记录boot.bin的启动镜像文件**
3.  dd if=floppy.img of=myos.img skip=1 seek=1 bs=512 count=2879 **在 bin 生成的镜像文件后补上空白，成为合适大小的软盘镜像，一共2880个扇区，略过第一个**

## 用软盘启动系统 ##

1.  将myos.img下载到windows
2.  VMWare创建空的虚拟机
    
    1.  文件 - 创建新的虚拟机 - 典型
    2.  稍后安装操作系统
    3.  其他
    4.  一路next 完成
    5.  虚拟机设置，去掉CD/DVD选项中“启动时连接”
    6.  网络，选择“仅主机模式”，勾选“启动时连接”（好像无所谓）
    7.  添加软盘驱动器 使用软盘映像 找到myos.img
3.  启动虚拟机

## 为什么是0x7C00? ##

参考：https://www.glamenv-septzen.net/en/view/6

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200601203019632.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[https_haokan.baidu.com_v_vid_11928468945249380709_pd_bjh_fr_bjhauthor_type_video]: https://haokan.baidu.com/v?vid=11928468945249380709&pd=bjh&fr=bjhauthor&type=video
[https_www.sohu.com_a_255397866_468626]: https://www.sohu.com/a/255397866_468626
[https_haokan.baidu.com_v_vid_16026741635006191272_pd_bjh_fr_bjhauthor_type]: https://haokan.baidu.com/v?vid=16026741635006191272&pd=bjh&fr=bjhauthor&type=video
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200601203146928.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200601203227774.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200601203227716.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20200601203256172.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20200601203841931.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200601203348490.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20200601203926106.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2020060120411978.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200601204118945.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20200601204147703.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/2020060120421558.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[https_preshing.com_20120515_memory-reordering-caught-in-the-act]: https://preshing.com/20120515/memory-reordering-caught-in-the-act/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/20200601204403679.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/20200601204418920.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 9]: https://img-blog.csdnimg.cn/20200601204438281.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 10]: https://img-blog.csdnimg.cn/20200601204506146.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 11]: https://img-blog.csdnimg.cn/20200601204529646.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 12]: https://img-blog.csdnimg.cn/20200601204636844.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 13]: https://img-blog.csdnimg.cn/20200601204713570.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 14]: https://img-blog.csdnimg.cn/20200601204731774.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 15]: https://img-blog.csdnimg.cn/2020060120475424.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200601204902478.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200601204903965.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200601204905173.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200601204903204.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200601204902636.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 16]: https://img-blog.csdnimg.cn/20200601205127317.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200601205200279.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20200601205200473.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20200601205312106.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20200601205311914.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 17]: https://img-blog.csdnimg.cn/20200601205458805.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/2020060120541157.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/20200601205533536.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 16]: https://img-blog.csdnimg.cn/20200601205533753.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 17]: https://img-blog.csdnimg.cn/20200601205645755.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 18]: https://img-blog.csdnimg.cn/20200601205645836.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 19]: https://img-blog.csdnimg.cn/2020060120564694.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 20]: https://img-blog.csdnimg.cn/2020060120564624.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 21]: https://img-blog.csdnimg.cn/20200601205801358.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70 22]: https://img-blog.csdnimg.cn/20200601205801217.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx_size_16_color_FFFFFF_t_70_pic_center 18]: https://img-blog.csdnimg.cn/2020060120583067.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3ODkyNDAx,size_16,color_FFFFFF,t_70#pic_center