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

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提高效率
java程序员应该掌握的底层知识

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在读等待的同时执行指令（乱序不是乱，为了效率）
java程序员应该掌握的底层知识
乱序的证明：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？->禁止指令重排序
java程序员应该掌握的底层知识

有序性保障
- 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的写入对所有处理器可见。

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

底层屏障由lock指令实现的
java程序员应该掌握的底层知识

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

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

合并写

java程序员应该掌握的底层知识
由于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颗合适

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

NUMA（non uniform memory access）：非统一访问内存。从主板上会将cpu与内存分为不同的槽
java程序员应该掌握的底层知识
ZGC：NUMA Aware 分配内存会优先分配该线程所在CPU的最近内存

操作系统基本知识

启动

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

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

什么是操作系统

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

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

内核分类

微内核 - 弹性部署 5G IoT

宏内核 - PC phone

外核 - 科研实验中为应用定制操作系统 (多租户 request-based GC JVM)
java程序员应该掌握的底层知识

用户态与内核态

cpu分不同的指令级别

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

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

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

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

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

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

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

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

分配资源最重要的是：分配内存空间。线程调度执行（线程共享进程的内存空间，没有自己独立的内存空间）

纤程

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

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

目前2020 3 22支持内置纤程的语言：Kotlin Scala Go Python(lib)… Java? （open jdk : loom）
java程序员应该掌握的底层知识

纤程的实现

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>
        <!-- https://mvnrepository.com/artifact/co.paralleluniverse/quasar-core -->
        <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来完成，只在内核空间运行。

进程的创建和启动

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

僵尸进程

#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

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

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

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

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

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

通过ax寄存器填入调用号

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

返回值通过ax返回

java读网络 – jvm read() – c库read() - > 内核空间 -> system_call() （系统调用处理程序）-> sys_read()

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

从汇编角度理解软中断

搭建汇编环境

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：互相打扰

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

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

制作启动软盘

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

用软盘启动系统

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

为什么是0x7C00?

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

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

文章目录

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

相关书籍推荐

硬件基础知识

CPU的制作过程

CPU的原理

计算机组成

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

量子计算机

cpu的基础组成

存储器的层次结构

缓存

cpu的乱序执行

合并写

UMA与NUMA

操作系统基本知识

启动

什么是操作系统

内核分类

用户态与内核态

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

纤程

纤程的实现

纤程的应用场景

内核线程

进程的创建和启动

僵尸进程

孤儿进程

进程调度

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

从汇编角度理解软中断

内存管理

内存管理的发展历程

ZGC

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

内核同步机制

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

内核同步常用方法

汇编实现引导程序

编写汇编码

编译

制作启动软盘

用软盘启动系统

为什么是0x7C00?

java程序员未来发展前景大不大（java程序员需要掌握的知识）

java截取字符串后几位（java程序员必备的基础知识）

Java程序员需要掌握的英语词组

为什么说 Java 程序员到了必须掌握 Spring Boot 的时候？

java8中流式语法，18K以上的程序员还是要掌握下的

一名3年工作经验的java程序员应该具备的职业技能

分享Java程序员应该知道的10个调试技巧

2020年Java程序员应该学习的10大技术

2019年三年工作经验的Java程序员该掌握哪些技能？

菜鸟级的android程序员面试时候需要掌握的知识点

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

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