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

程序员文章站 2022-04-24 10:22:52

...

1 相关书籍推荐

读书原则：不求甚解，观其大略，大体读明白，先拿来用，用着用着，很多道理你就明白了
底层知识相关书籍
1. 《编码：隐匿在计算机软硬件背后的语言》
2. 《深入理解计算机系统》
3. C语言：《C程序设计语言》、《C Primer Plus》
4. 数据结构：《Java数据结构与算法》、《算法》、《算法导论》、《计算机程序设计艺术》
5. 操作系统：《Linux内核源码解析》、《Linux内核设计与实现》、《 30天自制操作系统》
6. 网络：《TCP/IP详解-卷一》
7. 编译原理：《编译原理》、《编程语言实现模式》
8. 数据库：《SQLite源码》、《 Derby》（JDK自带数据库）

2 CPU的制作过程

Intel cpu的制作过程视频：https://haokan.baidu.com/v?vid=11928468945249380709&pd=bjh&fr=bjhauthor&type=video
cpu制作过程文字描述：https://www.sohu.com/a/255397866_468626

3 CPU原理

计算机需要解决的最根本问题：如何代表数字
晶体管是如何工作的：https://haokan.baidu.com/v?vid=16026741635006191272&pd=bjh&fr=bjhauthor&type=video
晶体管工作原理：https://www.bilibili.com/video/av47388949?p=2

4 CPU的基本组成

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

CPU有很多针脚，每个针脚1次可以接收1个电信号（1或0），通过这些针脚一次性可以读取到一堆的1和0，硬件上讲，就是给哪个针脚通电，哪些就是1，不通电就是0，我们需要将数据通过针脚输入给CPU，有几种方式，可以手工输入，不断自己通电断电，但太费劲，因此产生了内存，存放数据和运算过程，CPU可以自动从内存中读取这些数据，所以说内存的本质就是一个特别大的字节数组，存储了一堆电信号
总线：电线汇总到一起就是总线，CPU一次要从内存读取64个电信号，那么就有64个电线连到内存上
主板：连接cpu、内存、显卡、usb等各种元器件，主板中有很多电路
操作系统位数：32位和64位表示支持cpu一次性读取多少位数字，32位就是一次性可以读取32个数字。cpu可能一次性能读64位，但总线不一定，总线可能一次性只能读32位或128，
PC：Program Counter，程序计数器，用于记录当前正执行的指令地址
Registers：寄存器，用于暂时存储CPU计算需要用到的数据，一颗CPU上有上百个寄存器，所谓64操作系统，就是指寄存器一次性可以存放64bit的数据
ALU：Arithmetic & Logic Unit，运算单元，负责运算
CU：Control Unit 控制单元
MMU：Memory Management Unit，内存管理单元
cache：缓存

5 四核八线程是的含义

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

四核表示CPU有4个核心，而8线程，指1个核心中，包含1个ALU和2组Registers+PC。画面上的CPU其实表示的的是CPU核心
如果1个CPU核心中，如果只包含1个ALU和1组Registers+PC，此时Thread1的指令存放在PC中，而数据存放在Registers
一旦Thread2需要执行，就必须将Thread1的指令和数据先从PC和Registers中拿出，然后才能将Thread2的数据和指令放入，ALU才会对Thread2数据进行处理，这个过程叫做线程切换（context switch）
线程切换会耗费CPU资源
因此四核八线程，表示虽然CPU只有4个核心数，但可以一次性将多个线程数据存入到不同的Registers和PC中，ALU可以直接针对不同Registers+PC进行计算，而不需要将数据和指令来回拿出放入

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

汇编语言的本质：是机器语言的助记符，例如将01001000记作mov，10110011记为sub
执行过程：例如计算2+3
1. 计算机通电
2. CPU将2和3分别从内存，读取到两个寄存器中
3. 然后PC发现指令是add
4. 时钟发生器不断震荡通断电（CPU频率就是指每秒钟可以震荡的次数，GHz表示每秒钟可以震荡几十亿次)，从而推动CPU内部一步一步执行（执行多少步取决于指令需要的时钟周期，即一个指令需要震荡几次才能完成）
5. ALU计算出结果后，将结果存放到一个新的寄存器中
6. 将数据写回到内存或写回给显卡输出

5 CPU到各存储器的时间

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

6 多核CPU物理结构

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

7 缓存行

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

CPU读取数据时，按缓存行读，一次读一行数据，当CPU核心1读x变量时，先到自身的L1中查找是否有该数据，如果没有，继续到L2中查找，直到查找到内存中
当从内存中读取变量x时，会将与x处于同一缓存行的变量y一起读入，然后将内存中该缓存行，先复制传输给L3，再复制传输给L2，一直复制到L3中，这样L1、L2、L3中都有一份数据
CPU核心1处理完该缓存行后，会将该缓存行内容写回到内存
如果在CPU核心1将数据写回内存前，CPU核心2上读取y，那么x也会被读入，等到CPU2处理完y后，会将未修改的x值，重新写入内存，导致CPU核心1的修改失效
为防止这种情况的产生，产生缓存一致性协议，当某个CPU核心中修改了缓存行中任意数据，会强制其他CPU核心强制重新从内存读取这个缓存行中数据，缓存一致性协议也叫缓存锁
Intel采用的缓存一致性协议叫做MESI，MESI代表缓存的四种状态，某个缓存行被修改过后，在修改它的CPU核心上，就变为Modified状态，而在其他CPU核心上，变为Invalid状态，CPU核心发现缓存行中数据未Invalid状态后，就会从内存重新读数据进来
但对于那些跨越了多个缓存行数据，比如一个long类型数据，跨越了两个缓存行，此时如果想保存一致性，就需要总线锁，也就是当CPU核心需要访问某块内存时，将内存到L3中间的总线锁住，这样其他CPU核心就暂时无法读取内存中内容，当该CPU核心访问完成后再解除总线锁，其他CPU核心才能访问
总线锁效率太低，因此底层能使用mesi时，就不会使用总线锁
缓存行大小：不是固定值，Intel中缓存行为64字节，是实践后决定的，缓存行越大，局部性空间效率越高，但会导致读取时间越慢，因此需要取一个折中值
但由于缓存一致性协议，会导致伪共享问题，所谓的伪共享，就是两个不同线程同时修改同一缓存行中不同值时，无法真正同时进行修改，因为缓存一致性在第一个线程修改值后，要求第二个线程强制从内存重新读取

package com.mashibing.springboot;

public class T03_CacheLinePadding {
    //jdk8写法：400+ms
  	//1. jdk8中允许在属性上加@Contended注解，保证该成员变量不会与其他带有@Contended注解的变量位于同一缓存行，需要加启动参数 -XX:-RestrictContended才会生效，经测试intellij2020最新版中，自动加上了-XX:-RestrictContended参数，不需要自己配置即可生效
  	//2. 如果只在x上加@Contended不会生效
//    @Contended
//    volatile long x;
//    @Contended
//    volatile long y;

    //jdk7中写法：400+ms
  	//jdk7中，需要使用如下写法人为进行缓存行对齐，从而提高效率，但这种方式只对Intel的CPU有效，但对于其他CPU可能不生效，而jdk8中@Contended可以自动识别底层CPU缓存行大小，从而保证不会与其他变量位于同一缓存行
    public long p1, p2, p3, p4, p5, p6, p7;
    private volatile long x;
    public long p8, p9, p10, p11, p12, p13, p14;
    private volatile long y;

    //不考虑缓存行对齐的写法：2000ms
//    volatile long x;
//    volatile long y;

    public static void main(String[] args) throws Exception {
        T03_CacheLinePadding t = new T03_CacheLinePadding();
        Thread t1 = new Thread(() -> {
            for (long i = 0; i < 1000_00000L; i++) {
                t.x = i;
            }
        });

        Thread t2 = new Thread(() -> {
            for (long i = 0; i < 1000_00000L; 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);
    }
}

8 NUMA

UMA：统一内存访问，所有cpu访问同一块内容，大家的访问没有优先级
1. 不易扩展，CPU数量增多后引起内存访问冲突加剧
2. 经测试，4颗CPU一般比较合适

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

NUMA：非统一内存访问
1. 主板的插槽上，某块CPU会和某块内存放在一起
2. CPU对自己插槽上的那块内存访问是有优先访问权的，且访问自己插槽上的内存效率高，访问其他CPU对应的内存效率低

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

ZGC能够做到NUMA aware，也就是ZGC能够感知到你系统底层架构使用了NUMA，使用某个CPU分配对象时，会优先分配在和该CPU再同一插槽上的那块内存中

计算机启动过程（不重要）

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

通电后，BIOS芯片（现在已经升级为UEFI）加电，自检，看主板上连接的内存、硬盘等内容是否连接正常，之后加载硬盘上的启动控制器（bootloader，用于引导具体哪个操作系统）到内存。bootloader在硬盘上位置是固定的，在硬盘的第一个扇区上，加载到内存后，bootloader开始引导，弹出界面，选择具体使用哪个系统
cmos芯片记录可以配置的信息，例如从u盘启动还是从哪个盘符启动，该芯片必须加电，不加电信息就没了，因为主板上有块电池，一直给cmos通电
进入操作系统后，所有操作，就都由操作系统完成了

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

OS：操作系统，这里都是指linux操作系统。书：linux内核设计与实现

1. 操作系统本身就是一个软件

2. 这个软件即可以管理cpu、内存等硬件，又可以管理其他应用，例如进程管理
3. 大部分操作系统分为两层，内核kernel，管理硬件，和外围程序shell，管理应用程序
4. kernel具体功能
   	1. cpu调度
   	2. 内存管理
   	3. 文件系统
   	4. 进程调度
   	5. 设备驱动
   5. 宏内核：kernel相关程序放在一块，存在一块内存。当宏内核接受到读取某文件指令时，会自己找一下自带的读取文件的程序，然后访问硬盘，完成文件读取操作
   6. 微内核（智能家居中的控制单元）：kernel只有责进程调度程序，因此如果收到了读取文件的要求，会到另一块芯片、或网络中另一块芯片上查找具备该功能的程序
   7. 外核：为某种应用程序专门定制的kernel

内核分类

微内核 - 弹性部署 5G IoT

宏内核 - PC phone

外核 - 科研实验中为应用定制操作系统 (多租户 request-based GC JVM)

VMM：硬件资源过剩的情况，可以在硬件和操作系统间加上一个虚拟层，VMM，这样，硬件上就可以跑很多操作系统

用户态与内核态

cpu分不同的指令级别

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

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

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

啥叫用户态？

进程线程纤程中断

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

答案：进程就是一个程序运行起来的状态，线程是一个进程中的不同的执行路径。专业：进程是OS分配资源的基本单位，线程是执行调度的基本单位。分配资源最重要的是：独立的内存空间，线程调度执行（线程共享进程的内存空间，没有自己独立的内存空间）

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

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

目前2020 3 22支持内置纤程的语言：Kotlin Scala Go Python(lib)… Java? （open jdk : loom）

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 线程池：很短的计算任务，不需要和内核打交道，并发量高！

僵尸进程

#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

中断

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

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

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

通过ax寄存器填入调用号

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

返回值通过ax返回

java读网络 – jvm read() – c库read() - >

内核空间 -> system_call() （系统调用处理程序）

-> sys_read()

从汇编角度理解软中断

搭建汇编环境

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?

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XLnmSwD2-1598099193401)(c:\work\courses%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BB%84%E6%88%90%E5%8E%9F%E7%90%86\imgs\8080%E5%AE%9E%E6%A8%A1%E5%BC%8F%E5%86%85%E5%AD%98%E5%B8%83%E5%B1%80.png)]

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

相关标签： Java程序员应该掌握的底层知识

上一篇：坚果产品经理也期待！MIUI 12来了：对高刷做全局优化

下一篇： 6500元！微星推出全新3A游戏本：4800H+RX5500M加持

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

1 相关书籍推荐

2 CPU的制作过程

3 CPU原理

4 CPU的基本组成

5 四核八线程是的含义

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

5 CPU到各存储器的时间

6 多核CPU物理结构

7 缓存行

8 NUMA

计算机启动过程（不重要）

内核分类

用户态与内核态

进程 线程 纤程 中断

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

纤程的应用场景

僵尸进程

孤儿进程

进程调度

中断

从汇编角度理解软中断

搭建汇编环境

内存管理

内存管理的发展历程

ZGC

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

内核同步机制

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

内核同步常用方法

汇编实现引导程序

编写汇编码

编译

制作启动软盘

用软盘启动系统

为什么是0x7C00?

作为程序员必须掌握的Java虚拟机中的22个重难点（推荐0

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

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

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

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

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

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

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

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

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

进程线程纤程中断

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