JAVA程序员需要了解的计算机底层知识（1）

最新推荐文章于 2023-03-27 23:36:47 发布

戏入人生。

最新推荐文章于 2023-03-27 23:36:47 发布

阅读量1.1k

点赞数 1

分类专栏：必备底层文章标签： java 编程语言面试多线程

本文链接：https://blog.csdn.net/xi_rurensheng/article/details/105566605

版权

必备底层专栏收录该内容

7 篇文章 0 订阅

订阅专栏

JAVA程序员需要了解的计算机底层知识（1）

CPU、内存？

CPU的执行原理：cpu是电脑的核心，负责计算，里面有很多层晶管，用于处理数据的计算，cpu有很多只脚针用于读取数据，cpu只认识0个1的二进制，cpu读取0和1的过程其实就是很多只脚针通电断电的过程（高电平和低电平），但是又不可能我们自己手动去控制cpu脚针的通电断电的过程，这个时候我们就要让写好的数据存储到一个地方，让cpu自己去读取，这个地方就是内存，内存的本质又是什么？内存的本质就存储着一些电信号，而这些电信号通过总线跟我们的cpu相连接，cpu把这些1个0读进来之后，做一些内部的计算，这个计算的过程需要通过晶体震荡器通电断电一步一步的往前走。有的计算需要三步，有的计算需要五步，不一定是几步，在cpu看来，内存就是它的仓库，这样就不需要手工的控制cpu脚针的通电断电了。

什么是总线？

就是电线汇总到一起，64位的cpu，也就是说连接到内存上的电线至少64根。

所谓操作系统64位，其实是一个软件，多少位是可以自己控制的，他可以支持32位或者64位的，所谓支持支持的是cpu，cpu每次读取的时候是一次性读取32位二进制还是64位二进制。

注意cpu读取数据跟总线没有太大关系，有的总线一次读取32位，有的总线一次读取128位，但是cpu每次读取是固定的，128位可以多分几次读取。

显卡？

就是cpu经过计算之后，返回电信号给内存，也可以写给显卡，显卡可以认为是一块缓存，这个缓存对应着屏幕上的每一个点，对应着屏幕上的像素，颜色等信息。

内存是如何把数据写给显卡的？

注意：并不是cpu写给显卡，而是内存DMA的机制，直接通过内存总线写给显卡。
这个时候，电脑显示器有一个刷新率，60HZ 、144HZ就是不断的从显卡里面读取数据，在屏幕上进行刷新。所以只需要把数据写到显卡里，我们屏幕显示器上就能显示出数据了。

主板

主板，用来承载cpu，内存，磁盘，显卡，相当于一个桥梁、一个纽带。

汇编语言的本质？

CUP是来计算从内存读过来的数据，但是这些数据都是0和1的二进制，最早起的程序员据说就是使用0和1来编写代码的，这样就造成了编程和可读性的困难，于是某些010101010这样的二进制起了个别名，比如add，remove之类的别名。这些别名也称之为助记符。其实他就是机器语言。

C和JAVA的class二进制码都可以被CPU执行吗？

答案是否定的。

C编译完之后，直接进就是机器码，可以直接被CPU执行。

JAVA编译之后，形成class二进制码，cpu不能执行这个二进制码，在执行的过程中，读一条指令，需要交给jvm，翻译成机器码，再交给cpu执行。中间间隔了一个jvm，所以可以运行在不同的平台上。

一个程序的加载过程

这里拿QQ举例，就是一个程序QQ在磁盘里，鼠标双击的时候，操作系统内核会把已经编译好的程序加载到内存中，cpu要执行的QQ的时候，会读取内存中的指令，数据进行运算，运算完的结果再写回到内存。

在这里插入图片描述

CPU的组成？

PC：计数器，就像jvm里面的计数器，用来记录内存指令读取位置的。

Registers：寄存器，用于存储即将要被计算的数据，一个cpu有很多很多寄存器。64位cpu其实就是指的registers一次性能存储64位。其相当于JVM中栈对应的本地变量表。

ALU：运算单元：就是做运算用的。

CU：控制单元

cache：缓存行

四核八线程CPU怎么理解？

在这里插入图片描述

四核八线程其实就是一个ALU对应多个registers寄存器，平时在读取数据的时候，就会把一个线程相关的数据存储在registers里，指令地址存储在PC里面，之后ALU对数据进行计算，如果CPU时间片到了切换线程的时候，就可以把registers直接切换到下一个registers里进行下一个数据的运算。而不用像只有一个registers的时候，在切换线程的时候，需要先把当前registers的数据存回内存，再读取下一个线程的数据到这个registers中进行计算，这样就会节省不必要的资源在切换线程回写到内存的过程。

几核几核指的是几个ALU，几线程指的是一次性有多少个registers对应线程。

CPU缓存的结构

在这里插入图片描述
首先说一下为什么有缓存，CPU到到不同部件的读取速度是不一样的。
1.从CPU到registers寄存机的速度是小于1纳秒（1ns）的。
2.从L1缓存读取数据大概也要1ns。
3.从L2读取数据大概要3ns。
4.从L3读取数据大概需要15个ns。
5.最慢的是从内存取数据，大概要80ns。

在读取数据的时候是按块读取，这些块，在缓存的领域被称作缓存行，在内存领域被称之为内存页，在硬盘领域被称之为硬盘块。

缓存块是解决io读取频繁效率太低的问题，所以一次读取一块，可以节省io消耗的资源

cpu的计算速度过于快，而从registers取数据的速度相比于从内存取数据大概相差了100倍。而缓存的概念解决了计算速度大于读取速度的问题，每次CPU读取数据，会先从先从最近的L1缓存找，如果找不到再从L2找，最后是L3，如果找不到，才会从内存中读取一块数据缓存进L3、L2、L1中。这样就会大大加快读取速度。

在这里插入图片描述
读取数据会先把数据读到缓存行，如果有一个数据同时被两个线程访问，其中一个cpu修改了数据，这个时候会触发MESI Cache数据一致性协议，会使另一个线程的缓存行失效，另一个数据会从新从内存中读取新的数据。

在这里插入图片描述
但是有的数据，一个缓存行无法装下，缓存行不适合的情况下，这个时候如果要保持数据一致性，需要锁总线，就是整合总线都会被锁住，只有自己可以访问，自己访问完了别的线程才能去访问，这个是最终的解决方案。这个方案肯定比缓存锁的方式效率低。能用缓存锁MESI的方式不会用总线锁。

MESI缓存一致性协议

简单的讲，就是给cache line标记四种状态，分别是Modified（被修改）、Exclusive（独享的）、Shared（共享的）、Invalid（失效的）。根据不同的状态进行操作达成数据的一致性。

参考：https://www.cnblogs.com/z00377750/p/9180644.html

每次读取“一块”数据，造成数据伪共享？

缓存行对齐，对于一些特别敏感的数字，会存在线程高竞争的访问，为了保证不发生线程伪共享（其实就是读取数据是按照块来读取进去缓存行，可能临近没有关系的数据会一块读取到缓存行，多个线程同时读取到了同一行的数据进入缓存行时，为了使线程之间的可见性，会使用volatile关键字，这样势必会使其他线程的缓存行失效进而从内存中从新读取数据，进而造成性能的降低），可以使用缓存对齐的编程方式。
在jdk7中，多采用long padding ，大白话就是声明long类型的变量从P1-P7进行占坑，在声明真正想使用的变量。之后再声明P8-P14. 这样中间的变量就可以保证在读取的时候同一缓存行，进而避免了伪共享。
在JDK8中可以在需要独立缓存行的变量上加入@Contended注解，并且设置虚拟机参数JVM：-XX:-RestrictContended 参数。

性能测试代码

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);
    }
}

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);
    }
}