文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

Java面试必备八股文

2023-08-16 19:30

关注

文章目录

一、Java基础篇

1.1)Java有哪几种数据类型

1.2)JVM、JRE和JDK的关系

JVM指的是Java的虚拟机,Java程序需要运行在虚拟机上,不同的平台都有自己的虚拟机,所以Java语言实现了跨平台。

JRE指的是Java的运行时环境,包括需要的大量的类库和Java的虚拟机。

JDK指的运行时候的需要的一些工具类和运行时环境,比如包括javac.exe ,javadoxc.exe 一系列用于编译字节码工具 打包文档的工具

1.3)Switch支持的数据类型?

jdk1.5之前 byte、short、int、char

jdk5 ~ jdk1.7 加入了enum

jdk1.7之后 加入了String

*注意 不支持long类型

1.4)为什么float=3.4报错

4 默认是浮点double类型的,如果赋值给float是向下转型,会出现精度缺失,,需要强制转换

1.5)final 有什么用?

用于修饰类,方法,变量(属性):

1.6)String有哪些特性

首先String是 private final char[]

1.6)Stringbuffer和 Stringbuilder有什么不同?

首先他们都是继承AbstractStringBuilder,相对于String来说是可变的字符串,只不过Stringbuffer加了synchronized所以是线程安全的,而Stringbuilder是线程非安全的

1.7)== 和 equals 的区别

== 默认是比较两个对象的引用地址的,而equals默认情况是==比较规则,但是不同的类会重写掉Object类的equals从而改变了equals的比较规则,比如String类的equals方法就是比较他们两个的内容是否相等

1.8)hashCode和equals

两个对象相等他们的hashCode和equals一定相等,但是hashCode相等的两个对象未必相等

1.9)方法重载和方法重写区别

1.10)面向对象和面向过程的区别

面向过程:就是具体化的一步一步的去实现,优点 就是性能比较快因为不需要进行实例化。 缺点就是不容易进行维护,扩展和复用

面向对象:因为面向对象的三大特点就是 封装、继承和多态

1.11)ArrayList 和LinkedList 的区别

1.12)说一说HashMap数据结构

HashMap通常是key-value键值对的方式进行存储,在JDK1.7的时候就是通过数组+链表的形式存储,每个数组存储的是一个一个的Entity组成的链表,这些链表上的数字都有一个特点就是Hash值相同,当数据量比较大的时候链表的长度比较大,这个时候查找的时间复杂度就比较大所以。在JDK1.8的时候引入了红黑树概念,当一个链表上的长度大于8的时候并且数组长度大于64这个时候链表就自动转换成红黑树,如果数组长度没有达到64那么此时就对数组进行1倍的扩容。

而且在JDK1.7和1.8还有一个改动就是插入的方式,由于JDK1.7的时候插入方式是头插法,在多线程的方式下会出选循环链表情况,所以1.8改为了尾插法方式。

扩容有三个地方

HashMap是线程不安全的,如果要保证线程安全那么可以使用ConcurrentHashMap

1.13)ConcurrentHashMap原如何保证的线程安全?

JDK 1.7 时候是使用分成16个Seagment段,每个Seagment里面存储着一个HashMap和一个锁,所以说1.7能支持最大的并发量也就是16个线程

JDK1.8采用的CAS + Synchronized,每次插入的时候判断是否是第一次插入,是就通过CAS插入,然后判断f.hash是否=-1,如果是的那么其他线程在扩容,当前线程也会参与扩容;删除方法用了synchronized修饰,保障并发下删除元素的安全

1.14)抽象类和接口的区别

继承:抽象类是只能单继承的,接口是可以多实现的

属性:属性修饰符也不一样,抽象累可以是public protect 默认不写 还有final 修饰,但是接口只能是public static final修饰

方法:抽象类既可以抽象的方法,也可以具体的方法,接口只有抽象的方法,而且子类必须实现

二、多线程篇

2.1) *简述线程、进程的基本概念。以及他们之间关系是什么

2.2)线程池

*线程池有七个参数?

corePoolSize: 线程池核心线程数最大值

maximumPoolSize: 线程池最大线程数大小

keepAliveTime: 线程池中非核心线程空闲的存活时间大小

unit: 线程空闲存活时间单位

workQueue: 存放任务的阻塞队列

threadFactory: 用于设置创建线程的工厂,可以给创建的线程设置有意义的名字,可方便排查问题。

handler: 线程池的饱和策略事件,主要有四种类型。

*线程池的执行过程?

当提交一个线程执行任务时候 ,先看有没有空闲的核心线程如果有就执行,如果没有就看阻塞队列中有没有满的状态,如果没有放满则放入队列中,否则就直接看线程数量是否大于非核心线程数量,如果没有就直接创建一个非核心线程,否则就是按照指定的拒绝策略给处理。。如果一个非核心线程在某个一段时间类是空闲的那么线程池就会把这个线程自动销毁掉。

四种拒绝策略
五种阻塞队列 (5)
五种创建线程的方式池的方式:
使用无界队列的线程池会导致内存飙升吗?

会的,newFixedThreadPool使用了无界的阻塞队列LinkedBlockingQueue,如果线程获取一个任务后,任务的执行时间比较长(比如,上面demo设置了10秒),会导致队列的任务越积越多,导致机器内存使用不停飙升,最终导致OOM。

2.2)线程、进程、协程的区别

进程:进程是操作系统分配系统资源和内存空间的最小单位。进程是独立的一块空间,所以资源和内存空间的切换是特别消耗资源的。

线程:线程也叫做轻量级的进程,是操作系统调用执行的最小单位。线程的资源是依赖于他的父进程,所以他的资源是共享的,线程的切换需要转换到内核态开销相对于小一些。

协程:协程是一种轻量级的线程,协程是直接在用户态就可以控制,具有对内核态来说是不可见的,所以协程的上下文切换更加的节约资源消耗。

2.3)什么是上下文的切换

上下文的切换指的是CPU寄存器和程序计数器存储的数据进行切换,而内存数据的改变只有在内核态才能进行。所以上下文切换对系统来说是巨大的成本。

2.4)Java有几种创建线程的方式

2.5)sleep和wait区别

2.6)Java的内存模型

JMM屏蔽了各种硬件和操作系统的内存访问差异,实现让Java程序在各平台都能够达到一致的内存访问效果,它定义了Java如何将程序中的变量在主存中读取

具体定义:所有变量都在主存中,主存是线程的共享区域,每个线程都有自己独有的工作内存,线程想要操作变量必须从主存中copy一份到自己的工作区域,每个独立内存区域相互隔离。

所以这个时候读写存在延迟,且不是原子操作,所以就出现了一些列的线程安全操作。比如 原子性、可见性、有序性。

image-20220831215853964

2.6)保证并发安全的三大特性?

原子性:一次或多次操作在执行期间不被其他线程影响

可见性:当一个线程在工作内存修改了变量,其他线程能立刻知道**(利用内存原子操作解决或者内存屏障或者lock前缀)**

有序性:JVM对指令的优化会让指令执行顺序改变,有序性是禁止指令重排**(内存屏障)**

2.7)ThreadLocal原理

每一个线程创建变量的副本,不同线程间是不可见的,保证线程安全。每个线程都维护一个ThreadLocalMap,key为threadlocal实例,value是保存的副本。

但是使用ThreadLocal会存在内存泄漏问题,因为key 是弱引用,value是强引用,每次GC时key都会回收,而value不会被回收。所以为了解决内存泄漏问题,可以在每次使用完后删除value或者使用static修饰ThreadLocal,可以随时的获取value。

第二个会出现内存溢出问题,如果使用的是线程池的方式去使用ThreadLocal话,那么就会出现存储的value一直存在,这样就一直堆积。

image-20220831220753564

2.8)什么是CAS锁

CAS锁可以保证原子性,思想是更新内存是会判断其内存的值是否被修改了,如果没有被修改就直接更新,如果被修改了,就得重新去获取值,知道更新为止。这样是有缺点的:

解决ABA问题,可以通过加入版本控制

2.9)Synchronized锁原理和优化

在JDK1.6以后Synchronized引入了偏向锁、轻量级锁、重量级锁、锁的粗化、锁消除的优化。并发性能基本和Lock持平的。

image-20220901114133488

轻量级锁:当锁是偏向锁时,有另外一个线程来访问,会撤销掉偏向锁,然后升级为轻量级锁,这个线程会通过自旋方式不断获取锁,不会阻塞,提高性能

重量级锁:轻量级锁尝试去获取到锁,如果获取失败线程就会进入阻塞状态,该锁会升级为重量级锁,重量级锁时,来竞争锁的所有线程都会阻塞,性能降低

注意,锁只能升级不能降级

image-20220901115158489

image-20220901115635895

image-20220901115801136

2.10)synchronized和ReentrantLock的区别:

2.11)为什么AQS使用的双向链表

因为有一些线程可能发生中断 ,而发生中断时候就需要在同步阻塞队列中删除掉,这个时候就会用到prev和next方便删除掉中间的节点

2.12)有哪些常见的AQS类

2.13)死锁产生的4个必要条件

互斥条件:进程要求对所匹配的资源进行排他性控制,即是一段时间内某资源仅为一进程所占有

请求和保持条件:当进程因请求资源而阻塞时,对已获得的资源保持不放

不剥夺条件:进程已获得的资源在未使用完之前不,不能剥夺,只能在使用完时有自己释放

环路等待条件:在发生死锁时,必须存在一个进程–资源得环星链

2.14)预防死锁

资源一次性得分配:一次性分配所有得资源,这样就不会有请求了(破坏请求条件);只要一个资源得不到分配,也不给这个进程分配其他得资源(破坏请求保持条件)

可剥夺条件:即当某个进程获得部分资源,得不到其他得资源,则释放已有得资源(破坏补课剥夺得条件)

资源有序分配法:系统分配资源编号,每一个进程按编号递增的顺序请求资源,释放则反之(环路破坏)

2.15)解除死锁

**剥夺资源:**从其它进程剥夺足够数量的资源给死锁进程,以解除死锁状态;

**撤消进程:**可以直接撤消死锁进程或撤消代价最小的进程,直至有足够的资源可用,死锁状态.消除为止;所谓代价是指优先级、运行代价、进程的重要性和价值等。

2.16)CPU密集型和IO密集型 的线程数设置

CPU 密集型:对于这样的任务最佳的线程数为CPU核心数的1~2倍,如果设置过多的线程,就会造成不必要的CPU上下文切换,性能相对于比较低

IO密集任务:由于IO读写是比较消耗时间的,并不会特别的消耗CPU的资源。对于这种任务最大的线程数一般大于CPU核心数的很多倍。

线程数 = CPU 核心数 *(1+平均等待时间/平均工作时间

三、JVM篇

3.1)Java中都有哪些引用?

强引用 :发生GC时候不会被回收

软引用:发生内存满(内存溢出的时候)会被回收(通常用于缓存)

弱引用:发生下一次GC时候会被回收

虚引用:无法通过虚引用去获取对象。用途:用于gc时返回一个通知

3.2)JVM运行时数据区域(内存结构)

首先编译器通过把Java代码转换成字节码,类加载器把字节码加载到运行数据区域的方法区内,而字节码只是一套JVM规范指令,所以这个时候需要执行引擎将字节码翻译成底层系统指令,在交给CPU去执行,这个过程需要用到其他语言本地库接口

3.3)JVM类加载过程

主要分为 加载 -> 链接 - > 初始化 三步骤:

注意:值得注意的是:加载阶段与连接阶段部分内容是交叉进行的,但开始时间有先后顺序。

3.4)对象的创建过程

1、首先进行类的加载检查

虚拟机遇到一条new指令时,首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用,并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有,那必须先执行相应的类加载过程。
new指令对应到语言层面上讲是,new关键词、对象克隆、对象序列化等

2、分配内存

对象所需内存的大小在类 加载完成后便可完全确定,为对象分配空间的任务等同于把 一块确定大小的内存从Java堆中划分出来。

这个步骤有两个问题:

如何划分内存。

在并发情况下, 可能出现正在给对象A分配内存,指针还没来得及修改,对象B又同时使用了原来的指针来分配内存的情况。

划分内存的方法:
解决并发问题的方法:
3、初始化

内存分配完成后,虚拟机需要将分配到的内存空间都初始化为零值(不包括对象头), 如果使用TLAB,这一工作过程也可以提前至TLAB分配时进行。这一步操作保证了对象的实例字段在Java代码中可以不赋初始值就直接使用,程序能访问到这些字段的数据类型所对应的零值。

4、设置对象头

初始化零值之后,虚拟机要对对象进行必要的设置,例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的GC分代年龄等信息。这些信息存放在对象的对象头Object Header之中。

在HotSpot虚拟机中,对象在内存中存储的布局可以分为3块区域:对象头(Header)、 实例数据(Instance Data)
和对齐填充(Padding)。 HotSpot虚拟机的对象头包括两部分信息,第一部分用于存储对象自身的运行时数据, 如哈希码(HashCode)、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时 间戳等。对象头的另外一部分是类型指针,即对象指向它的类元数据的指针,虚拟机通过这个指针来确定这个对象是哪个类的实例。

5、执行方法

执行方法,即对象按照程序员的意愿进行初始化。对应到语言层面上讲,就是为属性赋值(注意,这与上面的赋零值不同,这是由程序员赋的值),和执行构造方法。

image-20220812152038703

3.4.2)如何定位一个对象多大的空间?

在HotSpot虚拟机里对象内存布局分为3个部分:对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)

对象头:

  • 第一部分用于存储对象自身的运行时数据,如哈希码(HashCode)、GC 分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等。这部分数据的长度在32位和64位的虚拟机(未开启压缩指针) 中分别为32个比特和64个比特, 官方称它为“Mark Word”。
  • 另外一部分是类型指针,即对象指向它的类元数据的指针,虚拟机通过这个指针来确定这个对象是哪个类的实例。

如果对象是一个 java 数组,那么在对象头中还有一块用于记录数组长度的数据。

image-20220811170431701

案例:

1)创建一个maven项目,引入依赖

    org.openjdk.jol    jol-core    0.16

2)新建一个类

@Datapublic class BaseEntity  {    private long id;    private double amount;    private int updateUserId;    private float f;    private char c;    private byte b;    private boolean bb;    private short ss;    private long[] list; //4byte    private String s; //4byte    private Long count; //4byte}

3)测试

public class ObjectHeaderTest {    public static void main(String[] args) {        BaseEntity baseEntity = new BaseEntity();        String toPrintable = ClassLayout.parseInstance(baseEntity).toPrintable();        System.out.println(toPrintable);    }}

打印结果

site.sunlong.obj.BaseEntity object internals:OFF  SZ               TYPE DESCRIPTION               VALUE  0   8                    (object header: mark)     0x0000000000000001 (non-biasable; age: 0)  8   4                    (object header: class)    0xf800c143 12   4                int BaseEntity.updateUserId   0 16   8               long BaseEntity.id             0 24   8             double BaseEntity.amount         0.0 32   4              float BaseEntity.f              0.0 36   2               char BaseEntity.c                38   2              short BaseEntity.ss             0 40   1               byte BaseEntity.b              0 41   1            boolean BaseEntity.bb             false 42   2                    (alignment/padding gap)    44   4             long[] BaseEntity.list           null 48   4   java.lang.String BaseEntity.s              null 52   4     java.lang.Long BaseEntity.count          nullInstance size: 56 bytesSpace losses: 2 bytes internal + 0 bytes external = 2 bytes total

4)测试结果解读

数据第1行(object header: mark):这个是Mark Word占用的字节数,64位机器上占用8个字节,32位机器上占用4个字节。

数据第2行(object header: class) :类型指针,在开启指针压缩的情况下占4个字节,未开启的情况下占8个字节,jdk1.6之后默认开启指针压缩。

数据第3-14行(除(alignment/padding gap)):BaseEntity对象属性类型占用字节数,一共占用39个字节。

其他数据行:对齐填充2个字节,由于Mark Word(8个字节)+类型指针(4个字节)+对象字节数(42个字节)=54个字节,54不是8的倍数,所以要填充2个字节凑够8的倍数。如果字节数之和刚好是8的倍数,则不需要对齐填充。

3.4.3)JVM类初始化顺序

父类静态代码块和静态成员变量->子类静态代码块和静态成员变量->父类代码块和普通成员变量->父类构造方法->子类代码块和普成员变量->子类构造方法

3.5)什么是内存泄漏?

就是不再使用的对象或者变量一直占用着内存中,而且GC也无法去回收。这种情况是因为长生命周期的对象持有短生命周期的对象的引用就会发生内存泄漏情况。

3.5.2)什么情况下会内存溢出?

堆内存溢出:(1)当对象一直创建而不被回收时(2)加载的类越来越多时(3)虚拟机栈的线程越来越多时

栈溢出:方法调用次数过多,一般是递归不当造成

3.6)简述一下Java的垃圾回收机制?

在Java中,程序员不需要去指定的释放对象。而是有JVM虚拟机自行的执行,有一个垃圾回收线程(守护线程)他的优先级比较低,他不会去主动的去执行,只有虚拟机空闲或者当前的堆空间满的时候,才会去触发,去扫描回收掉没有用的对象。

当创建一个对象的时候GC就会进行监控这个对象的地址、大小以及使用情况 。GC通过有向图的方式记录管理堆,通过这种方式来判断那些可达,哪些不可达,从而来判定是否回收。

程序员可以手动的进行System.gc()来通知gc运行,但是GC并不能保证GC一定会执行

3.7)如何判断是否能够回收?

两种方式:

3.8)垃圾回收算法有哪几种?

3.9)垃圾收集器

image-20220812225110308

Serial收集器:色而瑞

​ 新生代采用复制算法,老年代采用标记-整理算法。单线程,所以在发生GC时候需要暂停所有线程的工作。

Parallel Scavenge收集器:帕尔雷尔

​ 新生代采用复制算法,老年代采用标记-整理算法。多线程,Parallel Scavenge收集器关注点是**吞吐量(**高效率的 利用CPU)

ParNew收集器:帕尔new(jdk8默认设置的垃圾收集器)

​ 新生代采用复制算法,老年代采用标记-整理算法。和Parallel 相似主要用于配合CMS收集器使用。

CMS收集器:

​ CMS收集器是一种 “标记-清除”算法实现的。

​ CMS(Concurrent Mark Sweep)收集器是一种以获取最短回收停顿时间为目标的收集器。它非常符合在注重用户 体验的应用上使用,它是HotSpot虚拟机第一款真正意义上的并发收集器,它第一次实现了让垃圾收集线程与用 户线程(基本上)同时工作。

image-20220920163512395

3.10)内存对象的分配策略?

对象的内存分配通常是在 Java上分配(随着虚拟机优化技术的诞生,某些场 景下也会在上分配,
后面会详细介绍),对象主要分配在新生代的 Eden 区, 如果启动了本地线程缓冲,将按照线程优先在
TLAB 上分配。少数情况下也会直 接在老年代上分配。总的来说分配规则不是百分百固定的,其细节取
决于哪一种 垃圾收集器组合以及虚拟机相关参数有关,但是虚拟机对于内存的分配还是会遵 循以下几种

3.11)说一说如何理解双亲委派模型

类加载器主要有:

image-20220902173951286

双亲委派模型就是子加载器向父级加载器向上委托它加载,如果父加载器能加载那么子加载器就不用加载直接返回,如果不能加载就有子加载器进行加载。

这样做的好处就是:

**如何打破双亲委派模型:**重写loadClass(String, boolean)方法

四、MYSQL篇

4.1)数据库三大范式是什么

第一范式:每个列都不可以再拆分。

第二范式:在第一范式的基础上,非主键列完全依赖于主键,而不能是依赖于主键的一部分。

第三范式:在第二范式的基础上,非主键列只依赖于主键,不依赖于其他非主键。

在设计数据库结构的时候,要尽量遵守三范式,如果不遵守,必须有足够的理由。比如性能。事实上我 们经常会为了性能而妥协数据库的设计。

4.2)说一说B和B+树的区别?

B树的数据即存在非叶子节点上也存在于叶子节点上,而B+树所有的数据都是存在叶子节点。就是因为这个原因所以B+树存储的数据比较多,因为一个页的大小是16KB而B树的非叶子节点又存储了数据data,所以一个页锁存储的节点少一些,故如果使用B树那么层数会相应提高很多。

B+树的叶子节点还采用了双向链表的结构,这样也可以可以方便使用范围查找和所有数据的遍历。而B树有的数据存储在非叶子节点就做不到这一点,必须经过不断的回溯IO大大降低了效率

4.3)MyISAM 和 InnoDB的区别

4.4)什么是聚簇索引和非聚簇索引和覆盖索引

聚簇索引:就是将索引和值放在一起,根据索引可以直接获取值,

非主键索引:叶子节点存放的是数据行地址,先根据索引找到数据地址,再根据地址找数据

覆盖索引:覆盖索引就是所查找的结果集,在所查找的索引树当中已经存在了不用再进行回表操作

联合索引:多个字段联合起来的索引

4.5)除了索引我们写SQL时候还有那些优化?

4.6)NLJ BNL 算法

被驱动表:

驱动表:

通常使用小表使用驱动表,被驱动表字段如果不存在索引使用BNL算法,否则时候NLJ算法,因为他们扫描次行数相等,这个时候BNL算法的磁盘扫描而且扫描次数更少,他是先从磁盘中放入join_buffer中去,而且计算快得多。

4.7)为什么小表作为驱动表

驱动表首先会根据where字段进行过滤,然后再去跟非驱动表进行join关联的。

大表 1000 小表 100行记录

关联过程:

NLJ算法: 这个通常是在被驱动表关联字段存在索引情况下触发,首先将驱动表查询好的字段取出来(100次),然后因为有索引所以每一行查询好关联的记录去被驱动表(100)次。总共 100+100 = 200次

BNL算法: 把驱动表筛选出来的数据读取到join_buffer中去(100次),将大表的每一行取出来拿出来join_buffer每一行进行对比(100 * 1000)。如果join_buffer存不下去,那么分多次磁盘的IO读写进行和被驱动表对比。

4.7)索引下推:

就是当一个联合索引,第一个是模糊查询,导致后面的字段不能够使用索引 ,这个时候将索引查询到的数据进行回表操作,这个时候的回标任务比较大。所以MySQL自动优化采用了索引下推的机制,在筛选模糊查询的时候也进一步去筛选模糊查询后面的字段,这样可以大大的减少了回表的成本。

4.8)MySQL的事务特性

原子性:就是一个事务一系列的操作命令要么全部执行,要么全部执行失败。通过Undolog日志解决

持久性:事务一旦提交就不可改变,而且必须持久化到磁盘当中。通过Redolog日志解决

一致性:再一个事务对数据的查询结果必须是一致的。MVCC通过Undolog日志解决

隔离性:事务和事务之间互不影响。这个我们可以通过加锁来解决

4.9)使用索引就一定比没有使用索引好吗?

空间上的代价:每建立一个索引都要为它建立一棵B+树,每一棵B+树的每一个节点都是一个数据页,一个页默认会占用 16KB 的存储空间,一棵很大的B+树由许多数据页组成,那就是很大的一片存储空间。

**时间上的代价:**每次对表中的数据进行 增、删、改 操作时,所以存储引擎需要额外的时间进行一些 记录移位 , 页面分裂 、 页面回收 等操作来维护好节点和记录的排序。如果我们建了许多索引,每个索引对应的B+树都要进行相关的维护操作,会给性能拖后腿。

4.10)redolog好处?

防止实例挂了 或者宕机,这样就会丢失掉那一段时间的数据。有了redolog日志就直接降低了刷盘的频率。

三种输盘策略:redo log buffer -> page cache -> 磁盘

4.11)结合redolog和undolog 说一说一条sql 的执行过程

  1. 从磁盘中加载数据到buffer pool中
  2. 记录Undolog日志
  3. 更新buffer pool中的数据
  4. 记录redolog日志就是将更新的操作写入redolog buffer中
  5. redolog buffer 写入 到redolog文件
  6. 记录binlog日志(刷盘)

image-20220903112317973

image-20221016171756487

4.12)MySQL锁的分类

基于属性:

基于粒度:

4.13)什么是MVCC

MVCC是多版本控制,我们在解决隔离级别产生问题的时候,一般有两种方式

在每次的事务当中都会生成一个新版本ReadView的数据:

4.14)select 的执行原理(顺序)

SELECT ... FROM ... WHERE ... GROUP BY ... HAVING ... ORDER BY ... LIMIT...

这条sql 的执行步骤

FROM   ->  JOIN  ->  ON  ->  WHERE  ->  GROUP BY  ->  HAVING   ->  SELECT   ->  DISTINCT  ->  ORDER BY  -> LIMIT

客户端 -> 连接器 -> 词法分析器 -> 优化器 -> 执行器 -> 存储引擎

连接器:如果用户名密码认证通过,连接器会到权限表里面查出你拥有的权限。之后,这个连接里面的权限判断逻辑,都将依赖于此时读到的权限。

4.15)char和varchar区别

char列的长度是固定的,能存取的最大的长度是0~255之间,如果存储的是utf8那么就是3*255的字节;如果是GBK那么就是2*255

varchar分为两个部分存储,一个是存储数据一个是存储长度范围的,以前的最大长度是255 ,mysql5版本后就是0~65535(2^16)个字节 ,例外还需要1-2个字节(长度超过255时需要2个字节)来存储字符串的实际长度。

4.16)binlog日志的用途

4.17)如果我们发现一条Sql执行特别慢 我们该怎么去处理

  1. 我们先观察服务器的状态情况看是否是在周期性的波动情况,如果是那么看加缓存能不能解决掉
  2. 如果不能解决那么我们开启慢查询,分析慢查询的语句。看是SQL的执行时间长问题,还是SQL语句的等待过长原因。
  3. 如果是等待过长就调优服务器的参数,如果是SQL语句的原因那么我们就优化SQL语句,比如加索引优化啊数据库表的设计优化
  4. 如果上面还是不能解决,看SQL查询是否达到了瓶颈,如果是就读写分离(主从架构)分库分表(垂直分表,垂直分库,水平分表)

查看系统性能参数 SHOW [GLOBAL|SESSION] STATUS LIKE '参数';

统计SQL的查询成本 SHOW STATUS LIKE 'last_query_cost';

开启慢查询日志参数 set global slow_query_log='ON';

设置慢查询的时间阈值 set global long_query_time = 1;

查询有多少条慢查询的记录 SHOW GLOBAL STATUS LIKE '%Slow_queries%';

查看 SQL 执行成本 SHOW PROFILE

分析查询语句 EXPLAIN

4.18)哪些情况索引会失效

(1)where条件中有or,除非所有查询条件都有索引,否则失效

(2)like查询用%开头,索引失效

(3)索引列参与计算,索引失效

(4)违背最左匹配原则,索引失效

(5)索引字段发生类型转换,索引失效

(6)mysql觉得全表扫描更快时(数据少),索引失效

五、Redis系列

5.1)Redis有哪几种基本的数据类型

5.2)Redis持久化机制

​ redis的默认持久化机制,通过父进程fork一个子进程,子进程可以共享主线程的所有内存数据。bgsave 子进程 运行后,开始读取主线程的内存数据,并把它们写入 RDB 文件。此时,如果主线程对这些数据也都是读操作, 那么,主线程和 bgsave 子进程相互不影响。但是,如果主线程要修改一块数据,那么,这块数据就会被复制 一份,生成该数据的副本。然后,bgsave 子进程会把这个副本数据写入 RDB 文件,而在这个过程中,主线程 仍然 可以直接修改原来的数据。

​ 以日志形式记录每一次的写入和删除操作,策略有每秒同步、每次操作同步、不同步,优点是数据完整性高, 缺点是运行效率低,恢复时间长

5.3)Redis是单线程吗?

redis单线程仅局限于 他的网络IO流,和他的键值对读写操作。但是redis对于其他的功能,比如持久化、异步的删除、集群同步等操作,都是额外的线程操作的。

5.4)为什么Redis单线程还这么快

因为redis所有数据都是在内存中,所有的运算都是内存级别的,而且单线程避免了多线程切换的性能损耗问题。正因为 Redis 是单线程,所以要小心使用 Redis 指令,对于那些耗时的指令(比如keys),一定要谨慎使用,一不小心就可能会导致 Redis 卡顿。

5.5)Redis单线程还能处理那么多的并发客户端连接

Redis的IO多路复用:redis利用epoll来实现IO多路复用,将连接信息和事件放到队列中,依次放到文件事件分派器,事件分派器将事件分发给事件处理器。

5.6)什么是缓存穿透

缓存穿透就是查询到一些不存在的数据,本来缓存层就是为了保护存储层的,而这样直接穿透到存储层就起不到保护的作用。

**如何解决:**在缓存存这是访问的key 为 一个null的值,并设置一个过期时间。。或者提前在接口层做好校验工作

5.7)什么是缓存击穿

由于大批量的缓存在同一时刻失效,大量请求过来就穿透缓存到达存储层,可能造成存储层压力过大甚至挂掉。

**如何解决:**设置一个随机的过期时间,而不是同一时刻都过期。。或者加上互斥锁。。

5.8)什么是缓存雪崩

缓存雪崩指的是缓存层支撑不住或宕掉后,流量会像奔逃的野牛一样, 打向后端存储层。由于缓存层承载着大量请求, 有效地保护了存储层, 但是如果缓存层由于某些原因不能提供服务(比如超大并发过来,缓存层支撑不住,或者由于缓存设计不好,类似大量请求访问bigkey,导致缓存能支撑的并发急剧下降), 于是大量请求都会打到存储层, 存储层的调用量会暴增, 造成存储层也会级联宕机的情况。

1)预防和解决缓存雪崩问题

5.9)Redis如何实现key的过期删除?

采用的定期过期 + 惰性过期

定期删除 :Redis 每隔一段时间从设置过期时间的 key 集合中,随机抽取一些 key ,检查是否过期,如果已经过期做删除处理。

惰性删除 :Redis 在 key 被访问的时候检查 key 是否过期,如果过期则删除。

5.10)缓存与数据库双写不一致

在大并发下,同时操作数据库与缓存会存在数据不一致性问题

1)双写不一致情况

image-20220720130545417

2)读写并发不一致

image-20220720130709159

3)解决方案

5.11)Redis集群方案

(1)主从模式:多个master节点,多个slave节点,master节点宕机slave自动变成主节点

(2)哨兵模式:在主从集群基础上添加哨兵节点或哨兵集群,用于监控master节点健康状态,通过投票机制选择slave成为主节点

(3)分片集群:主从模式和哨兵模 式解决了并发读的问题,但没有解决并发写的问题,因此有了分片集群。分片集群有多个master节点并且不同master保存不同的数据,master之间通过ping相互监测健康状态。客户端请求任意一个节点都会转发到正确节点,因为每个master都被映射到0-16384个插槽上,集群的key是根据key的hash值与插槽绑定

5.12)Redis集群主从同步原理

主从同步第一次是全量同步:slave第一次请求master节点会根据replid判断是否是第一次同步,是的话master会生成RDB发送给slave。

主从复制(全量复制)流程图:

image-20221016181203213

后续为增量同步:在发送RDB期间,会产生一个缓存区间记录发送RDB期间产生的新的命令,slave节点在加载完后,会持续读取缓存区间中的数据

主从复制(部分复制,断点续传)流程图:

image-20221016181303002

5.13)Redis集群为什么至少需要三个master节点,并且推荐节点数为奇数?

新master的选举需要大于半数的集群master节点同意才能选举成功,如果只有两个master节点,当其中一个挂了,是达不到选举新master的条件的。

奇数个master节点可以在满足选举该条件的基础上节省一个节点,比如三个master节点和四个master节点的集群相比,大家如果都挂了一个master节点都能选举新master节点,如果都挂了两个master节点都没法选举新master节点了,所以奇数的master节点更多的是从节省机器资源角度出发说的。

5.14)Redis集群选举原理分析

当slave发现自己的master变为FAIL状态时,便尝试进行Failover,以期成为新的master。由于挂掉的master可能会有多个slave,从而存在多个slave竞争成为master节点的过程, 其过程如下:

slave发现自己的master变为FAIL

将自己记录的集群currentEpoch加1,并广播FAILOVER_AUTH_REQUEST 信息

其他节点收到该信息,只有master响应,判断请求者的合法性,并发送FAILOVER_AUTH_ACK,对每一个epoch只发送一次ack

尝试failover的slave收集master返回的FAILOVER_AUTH_ACK

slave收到超过半数master的ack后变成新Master(这里解释了集群为什么至少需要三个主节点,如果只有两个,当其中一个挂了,只剩一个主节点是不能选举成功的)

slave广播Pong消息通知其他集群节点。

六、Spring系列

6.1)你怎么理解Spring?

Spring是个轻量级的框架,简化了应用的开发程序,提高开发人员的系统维护性,不过配置消息比较繁琐,所以后面才出选了SpringBoot的框架。

Spring的核心组件 : Spring Core 、 Spring Context 、 Spring Beans

IOC是Bean的一个容器,Context是每个Bean之间依赖的关系。正是因为各种Bean建立的关系我们才构成了IOC容器为我们服务,而Core就是维护、建立和维护所需要的的工具。

6.2)Spring中的Bean 是线程安全的吗?

非安全的

原型Bean

对于原型Bean,每次创建一个新对象,也就是线程之间并不存在Bean共享,自然是不会有线程安全的问题。

单例Bean

对于单例Bean,所有线程都共享一个单例实例Bean,因此是存在资源的竞争。

如果单例Bean,是一个无状态Bean,也就是线程中的操作不会对Bean的成员执行查询以外的操作,那么这个单例Bean是线程安全的。比如Spring mvc 的 Controller、Service、Dao等,这些Bean大多是无状态的,只关注于方法本身。

但是如果Bean是有状态的 那就需要开发人员自己来进行线程安全的保证,最简单的办法就是改变bean的作用域 把 "singleton"改为’‘protopyte’ 这样每次请求Bean就相当于是 new Bean() 这样就可以保证线程的安全了。

6.3)Spring单例,为什么controller、service和dao确能保证线程安全?

Spring中的Bean默认是单例模式的,框架并没有对bean进行多线程的封装处理。

实际上大部分时间Bean是无状态的(比如Dao) 所以说在某种程度上来说Bean其实是安全的。

6.2)什么是IOC和AOP,你知道他们的原理吗?

**IOC:**IoC就是控制反转,是一种思想而不是技术实现,A类对象中需要B类对象,传统是自己手动new就是主动控制,IoC思想就是交给IoC容器管理,不再自己手动new,容器管理好对象以及依赖关系,需要的时候从容器里拿就行。

**IOC原理:**就是在给每一个bean进行实例化后,都要对他的属性进行填充,大多数我们都是使用@Autowire直接的填充依赖注入的,在实例化和实例化后之间会调用一个MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition一个寻找注入点的方法,然后在属性填充时候,首先是按照注入点的类型去寻找如果有多个选择@Qualifier注解寻找,如果还是有多个按照@Primary,@Priority,最后还是没有筛选出来一个唯一的注入就按照名字来查找

**AOP:**是面向切面的编程,AOP就是可以将那些与业务不相关但是很多业务都要调用的代码抽取出来封装起来,减少重复代码,思想就是不侵入原有代码的情况下对功能进行增强。

**原理:**SpringAOP是基于动态代理的,其中SpringAOP的底层的动态代理有两种方式,一种是对于实现接口的JDK Proxy方式,另外一种就是CgLib

  1. Aspect:表示切面,比如被@Aspect注解的类就是切面,可以在切面中去定义Pointcut、Advice等等
  2. Join point:表示连接点,表示一个程序在执行过程中的一个点,比如一个方法的执行,比如一个异常的处理,在Spring AOP中,一个连接点通常表示一个方法的执行。
  3. Advice:表示通知,表示在一个特定连接点上所采取的动作。Advice分为不同的类型,后面详细讨论,在很多AOP框架中,包括Spring,会用Interceptor拦截器来实现Advice,并且在连接点周围维护一个Interceptor链
  4. Pointcut:表示切点,用来匹配一个或多个连接点,Advice与切点表达式是关联在一起的,Advice将会执行在和切点表达式所匹配的连接点上
  5. Introduction:可以使用@DeclareParents来给所匹配的类添加一个接口,并指定一个默认实现
  6. Target object:目标对象,被代理对象
  7. AOP proxy:表示代理工厂,用来创建代理对象的,在Spring Framework中,要么是JDK动态代理,要么是CGLIB代理
  8. Weaving:表示织入,表示创建代理对象的动作,这个动作可以发生在编译时期(比如Aspejctj),或者运行时,比如Spring AOP

6.3)bean 的生命周期?

6.4)Bean实例化的时候是如何解决循环依赖?

循环依赖就是在创建A实例的时候里面包含着B属性实例,所以这个时候就需要去创建B实例,而创建B实例过程中也包含着A实例。 这样A实例还在创建的过程当中,所以就导致AB实例都创建不出来。

一级缓存 就是我们所说的Bean存储的经过完整的生命周期的单例池

二级缓存 缓存未经过完整的声明周期的Bean

三级缓存 缓存的是ObjectFactory其实存储的是一个动态代理类的一个实现类的拉姆达表达式,执行这个拉姆达表达式就会生成这个类的代理类。

有了这三级缓存我们就来看一看,他是如何解决的。

如果出现了循环依赖的问题,我们在创建A的过程中,需要创建B。这个时候就需要将A放入三级缓存并且不会执行那个拉姆达表达式,所以这个时候需要去创建B在创建B时候需要去依赖A,就直接去三级缓存中查找,并且判断需不需要进行AOP处理,如果需要就执行那个拉姆达表达式得到代理对象,如果不需要就不需要执行,直接取出原始的对象。将取出的对象放入二级缓存中,因为这个时候A还未经过完整的生命周期所以不能放入一级缓存。这个时候其他需要依赖A对象的直接从二级缓存中去获取即可。当B创建完成,A继续执行生命周期,当A完成了属性的注入后,就可以放入一级缓存了。

6.5)Bean实例化的三级缓存了解吗?

6.6)SpringMVC的工作原理

  1. 客户端(浏览器)发送请求,直接请求到 DispatcherServlet
  2. DispatcherServlet 根据请求信息调用并且找到对应的HandlerMapping,解析请求对应的 Handler
  3. 然后利用对应的适配处理器,并且调用处理器开始执行,执行过程中包括解析参数,返回ModelAndView
  4. Model 是返回的数据对象,View 是个逻辑上的 View
  5. ViewResolver 会根据逻辑 View 查找实际的 View
  6. DispaterServlet 把返回的 Model 传给 View(视图渲染)。

image-20220905083745006

6.7)Spring的事务实现方式?事务隔离级别?事务传播机制?

spring事务是在启动类上加一个@Configuration 和 @EnableTransactionManagement注解,然后再Service的方法上面加一个@Transactional注解就可以了。Spring使用的事务隔离级别默认是使用MySQL数据库的隔离级别。

事务的传播机制:

当前不存在事务:

当前存在事务:

6.8)讲一下SpringBoot里面比较常用的注解?

@configuration @handmapping @getmapping @postmapping @EnableTransactionManagement

@mapperScaner @commpoent @requestBody @restcontroller

6.9)MyBatis的 # 和 $ 有什么区别?

${}是properties文件的变量占位符,用于标签属性值和SQL内部,比如${driver}会被替换成com.mysql.jdbc.Driver。

#{}是SQL的参数占位符,实际上会被替换成 ?

6.10)SpringBoot 是如何实现自动装配的?

@SpringBootApplication下有三个注解:

6.11)什么情况下会出现事务失效场景?

数据库引擎不支持事务

传播机制不支持 事务,就是不以事务的情况运行

没有配置事务管理器数据源

没有被 Spring 管理

方法不是 public 的

​ @Transactional 只能用于 public 的方法上,否则事务不会失效,如果要用在非 public 方法上,可以开启 AspectJ 代理模式。

自身调用问题

异常被捕获了

异常的类型不匹配,默认是运行时的异常

七、分布式

7.1) 什么是CAP BASE理论

CAP:
一致性: 在分布式环境下,一致性是指数据在多个副本之间是否能够保持一致性的特性,等同于所有的节点访问同一份最新数据的副本。在一致性的需求下,当一个系统在数据一致的状态下执行更新操作后,应该保证数据仍然一致性的状态。
可用性:每次请求都能够保证正确的响应,但是不保证获取的数据为最新的数据。
分区容错性:分布式情况下在遇到任何的网络分区额故障的时候,仍然需要能够保证对外提供一致性和可用性的服务,除非是整个网络环境发生了故障。
BASE
基本可用:在分布式系统出现故障,允许损失部分的可用性(服务降级、页面降级)
软可用:允许分布式出现中间状态。而且中间状态不影响系统的可用性。这里的中间状态指的是data replication(数据备份节点)之间的数据更新可以出现延迟的最终一致性。
最终一致性:data replications 经过一段时间达到一致性。

7.2)重点协议CP(ZAB RAFT) AP( Distro)

强一致性:

任意时刻,所有的节点数据都是一样的。
2、一个集群需要对外部提供强一致性,所以只要集群内部的某一个数据发生了改变,那么就需要等待集群内其他服务器的数据同步完成后,才能对外部提供访问。
3、保证了强一致性,务必会损耗可用性

弱一致性:

系统中的某个数据被更新后,后续对该数据的读取操作可能会得到更新后的数值,也可能会得到更新前的数值
2、即使过来一段时间窗口,后续的读取也不能保证一致性

最终一致性

弱一致性的特殊形式,不保证在任意时刻节点上的同一份数据是相同的,但是随着时间的迁移,不同节点的同一份数据总是在趋向一致性变化
2、存储系统保证在没有新的更新的条件下,最终所有的访问都是最后更新的值

顺序一致性

任意一次读都能读到某个数据的最近一次写的数据
2、对其他节点之前的修改是可见的(已同步)且确定的,并且新的写入建立在已经达到同步的基础上

高并发、高可用、高性能

七、计算机网络

7.1)TCP/IP和UDP模型

分为应用层,传输层,网络层,数据链路层

网络的七层架构 :应用层,表示层,会话层,传输层,网络层,数据链路层,物理层

TCP/IP是面向连接的协议,发送数据前要先建立好连接,TCP提供了可靠的服务,也就是说通过TCP连接传输的数据是不会丢失,没有重复,并且按照顺序达到的。

UDP是无连接的协议,发送数据前是不需要建立连接的,没有可靠的协议。所以传输的过程中可以以任意的路径进行传输,并且传输的过程中是否能达到和到达的时间都是没有保障的。

7.2)从输入址到获得页面的过程?

7.3)TCP进行三次握手

image-20220906153520841

  1. 第一次握手:Client将SYN置1,随机产生一个初始序列号seq发送给Server,进入SYN_SENT状
    态;
  2. 第二次握手:Server收到Client的SYN=1之后,知道客户端请求建立连接,将自己的SYN置1,ACK
    置1,产生一个acknowledge number=sequence number+1,并随机产生一个自己的初始序列
    号,发送给客户端;进入SYN_RCVD状态;
  3. 第三次握手:客户端检查acknowledge number是否为序列号+1,ACK是否为1,检查正确之后将
    自己的ACK置为1,产生一个acknowledge number=服务器发的序列号+1,发送给服务器;进入
    ESTABLISHED状态;服务器检查ACK为1和acknowledge number为序列号+1之后,也进入
    ESTABLISHED状态;完成三次握手,连接建立。

7.4)采用两次握手行吗?

不可以,如果采用两次握手的话,那么只要服务端确认就建立了连接。如果client发送了一个请求过来,延迟了一个小时,一个小时候服务端接受到消息确认,他们建立了连接,但是这个时候client已经关闭了。但是服务端不知道。就会造成服务端一直发送数据,等待客户端的回消息,白白浪费许多资源。所以必须需要第三次握手的客户端确认。

7.5)可以采用四次握手吗?为什么?

这个肯定可以。三次握手都可以保证连接成功了,何况是四次,但是会降低传输的效率。

7.6)TCP的四次挥手

image-20220906161925322

  1. 第一次挥手:Client将FIN置为1,发送一个序列号seq给Server;进入FIN_WAIT_1状态;

  2. 第二次挥手:Server收到FIN之后,发送一个ACK=1,acknowledge number=收到的序列号+1;
    进入CLOSE_WAIT状态。此时客户端已经没有要发送的数据了,但仍可以接受服务器发来的数据。

  3. 第三次挥手:Server将FIN置1,发送一个序列号给Client;进入LAST_ACK状态;

  4. 第四次挥手:Client收到服务器的FIN后,进入TIME_WAIT状态;接着将ACK置1,发送一个
    acknowledge number=序列号+1给服务器;服务器收到后,确认acknowledge number后,变为
    CLOSED状态,不再向客户端发送数据。客户端等待2*MSL(报文段最长寿命)时间后,也进入
    CLOSED状态。完成四次挥手。

7.7)http和https的区别?

其实HTTPS就是从HTTP加上加密处理(一般是SSL安全通信线路)+认证+完整性保护
区别:

  1. https需要拿到ca证书,需要s钱的
  2. 端口不一样,http是80,https443
  3. http是超文本传输协议,信息是明文传输,https则是具有安全性的ssl加密传输协议。
  4. http和https使用的是完全不同的连接方式(http的连接很简单,是无状态的;HTTPS 协议是
    由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议,比http协议安全。)

7.8)cookie与session区别

  1. cookie数据存放在客户端上,安全性较差,session数据放在服务器上,安全性相对更高
  2. 单个cookie保存的数据不能超过4K,session无此限制
  3. session一定时间内保存在服务器上,当访问增多,占用服务器性能,考虑到服务器性能方面,应
    当使用cookie。

什么是cookie
cookie是由Web服务器保存在用户浏览器上的文件(key-value格式),可以包含用户相关的信
息。客户端向服务器发起请求,就提取浏览器中的用户信息由http发送给服务器
什么是session
session 是浏览器和服务器会话过程中,服务器会分配的一块储存空间给session。
服务器默认为客户浏览器的cookie中设置 sessionid,这个sessionid就和cookie对应,浏览器在向
服务器请求过程中传输的cookie 包含 sessionid ,服务器根据传输cookie 中的 sessionid 获取出
会话中存储的信息,然后确定会话的身份信息。

7.9)TCP如何保证可靠性的?

校验和(数据准确性)

序列号和确认应答(数据确认达到和有序)

超时重传(防止数据丢失)

  (1)数据在传输过程中由于网络原因等直接全体丢包,接收方根本没有接收到。 (2)接收方接收到了响应的数据,但是发送的ACK报文响应却由于网络原因丢包了。

TCP在解决这个问题的时候引入了一个新的机制,叫做超时重传机制。**简单理解就是发送方在发送完数据后等待一个时间,时间到达没有接收到ACK报文,那么对刚才发送的数据进行重新发送。**如果是刚才第一个原因,接收方收到二次重发的数据后,便进行ACK应答。如果是第二个原因,接收方发现接收的数据已存在(判断存在的根据就是序列号,所以上面说序列号还有去除重复数据的作用),那么直接丢弃,仍旧发送ACK应答。

连接管理

​ 连接管理就是三次握手与四次挥手的过程,保证可靠的连接,是保证可靠性的前提。

消息手动确认消费

RabbitMQ 持久化 消息持久化(发布确认方式) + 队列持久化(直接设置参数)

流量控制

拥塞控制

来源地址:https://blog.csdn.net/weixin_46350527/article/details/126683833

阅读原文内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯