跳到主内容
返回博客
Ernest Chen •
•
25 分钟

Java 知识点记忆点 - 补充

java
目录

什么是微服务？

将单体系统拆分职责相对于单一的一个个项目，每个项目提供不同的服务内容，服务之间的通过 rpc 来调用

一个服务的宕机、不可用，不会影响上下游服务，做到服务熔断隔离。根据每个服务访问流量的大小，指定服务的扩容和缩容，更加独立的进行，减少不必要资源的消耗。

Java 基础

抽象类和接口的区分？什么时候用接口 什么时候用抽象类？

  1. 抽象类主要是复用代码，将不同类具有相同行为 A 属性，交给抽象类实现，避免子类都去实现

  2. 接口只能定义方法（类行为的约束），类可以实现接口重写必须实现的方法，也可以额外写其他行为方法

Java 虚拟机

GC Roots 指的是哪些对象？

  1. JVM 栈中本地变量表中引用的对象

  2. 方法区中类静态属性引用变量

  3. 方法区中常量引用对象

  4. 本地方法栈中 Native 方法

方法区的回收有哪些对象？

废弃常量的回收、无用类的回收

  • 该类所有的实例都已经被回收，也就是 Java 堆中不存在该类及其任何派生子类的实例。 加载该类的类加载器已经被回收，这个条件除非是经过精心设计的可替换类加载器的场景，如 OSGi、JSP 的重加载等，否则通常是很难达成的。
  • 该类对应的 java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法

Spring 框架

Spring 和 SpringBoot 的区别？

  • springboot 极大简化 spring 所需要的配置

  • 内嵌了 tomcat 容器 简化部署

  • 引入 starters 集合应用依赖包 快速搭建业务框架

Spring 的事务隔离级别有哪些？（四种）

采用默认的隔离级别（DB 是怎样隔离级别 那 Spring 就是怎样的隔离级别）[MySQL 默认是可重复读]

  1. 读未提交（read uncommited）[脏读、不可重复读、幻读]

  2. 读已提交（read commited）[避免脏读，但可能不可重复读、幻读]

  3. 可重复读（repeatable read）[避免脏读和不可重复读，但可能幻读]

  4. 串行化（Serializable）[避免以上问题]

Spring 的事务传播级别有哪些？（七种传播行为）

支持当前事务：

  • 当前有事务加入事务，没有事务，新建事务

  • 当前有事务加入事务，没有事务，以非事务方式运行

  • 当前有事务加入事务，没有事务，抛弃异常

不支持当前事务情况：

前提：t <- 事务（transaction）

  • if 当前 ∃ t -> t 挂起，创建新的事务 t’

  • 以非事务的方式运行，if 当前 ∃ t -> t 挂起

  • 以非事务的方式运行，if 当前 ∃ t -> thows exception

  • If 当前∃ t -> 则创建一个事务作为当前事务的嵌套事务运行

Spring 中有哪些设计模式？分别有哪些

IOC：工厂模式 + 反射

AOP：代理模式

JDBCTemplate：模版模式

Spring 中 Bean：单例模式

SpringMVC 中的适配器 HandlerAdatper：适配器模式

spring 的事件驱动模型（ApplicationListener）：观察者模式

Spring 中 Observer 模式常用的地方是 listener 的实现

Spring 装饰器模式：在类名上有两种表现：一种是类名中含有 Wrapper，另一种是类名中含有 Decorator。

https://cloud.tencent.com/developer/article/1593982

代理模式和装饰器模式的区别？

代理模式是对代理对象加以控制，比如在对象前置或者后置，帮助你完成其他不用关心的事情，比如日志

装饰器模式是对装饰对象功能的增强，还是调用之前的方法，但有新的功能，是继承的替代模式

有哪些方法可以实现单例模式？

懒汉式（当只有在使用时才进行类对象创建）

饿汉式（静态常量、静态代码块）

双重检验锁也是懒汉式

静态内部类（静态属性只有在第一次加载类的时候初始化，通过 getInstance）

枚举

数据库 MySQL

数据库的事务特性？（四个）

原子性、一致性、隔离性、持久性

MySQL 的事物并发问题

脏读、不可重复读、幻读

MySQL 事物隔离级别

读未提交、读已提交、可重复读、可串行化

什么是 MVCC？怎么解决并发一致性问题

多版本并发控制，创建版本号和删除版本号（创建数据行的快照时的系统版本号）

可重复读下，对数据行修改事务 T1，读取的数据行快照的创建版本号 < 事务 T 的版本号（比较）

读取的数据行快照的删除版本号 > 事务 T 的版本号 否则表示这行数据已被删除

MVCC 解决了哪两种隔离级别？

提交读 和 可重复读

如何解决幻读问题？（在 X 隔离级别使用 XX 和 XX）

可重复读隔离级别 + Next-key locks

Next-key Lock: {
	1. record lock (锁一个记录上的索引，而不是记录本身，没有索引自动在主键上创建聚簇索引)
	2. gap lock （锁定索引之间的间隙，但不包括索引本身）
}

间隙锁锁的是哪些范围？什么操作导致间隙锁

快照读和当前读的区别？

select XXX 进行快照读 从 undo log 中快照获取

select XX for update 加锁保证拿取最新的数据

每条记录更新同时记录一条回滚记录（回滚操作记录 undo log）

数据库三范式？

第一范式：表中所有属性为最小原子属性，不可在分割 不能表中嵌套表

第二范式：属性对主键不存在部分函数依赖（学号、姓名、性别、年龄、课程号、分数）主键[学号、课程号]

第三范式：属性对主键不存在传递函数依赖（学号、姓名、学院、院长）主键[学号]

如何解决第二、第三？（看业务场景使用不同的范式）

undo 日志用来干嘛？binlog 日志？redo 日志？

  1. mvcc 使用 undo log（回滚日志：记录每行数据的版本）来实现快照 保存事务发生之前数据的快照版本，可以回滚

  2. redo log innoDB 引擎层日志（重做日志【往前滚 - 数据页的物理修改，且只能恢复最后一次提交的位置】）：记录事务操作变化后数据修改之后的值，不管事务是否提交都会记录。万一 DB 宕机异常启动，使用 redo log 恢复数据。

  3. binlog（归档日志）是二进制文件，是 MySQL Server 层记录的日志。MySQL 主从复制中，从库用主库的 binlog 进行复制

（binlog 只记录对数据的修改操作，用于主从复制、增量恢复）

redo log

是 innoDB 存储引擎层的日志，用来记录数据库事务操作的变化，记录是的数据修改之后的值，无论事物是否提交都会记录。在实例或者介质 crash，redolog 派上用场，用来恢复数据，保证数据的完整性。

更新操作涉及到 write ahead loging，先写日志在写磁盘。inndb 先把更新语句写 redo log 再更新内存，语句执行完毕后，在空闲的时候或者按照设定的更新策略将 redo log 中内容更新到磁盘当中。

有了 redo log，在 db 异常重启时候，根据 redo log 恢复，实现 crash-safe

RUNOOB 图标

redo 日志有固定大小，写满需要重头写

RUNOOB 图标

InnoDB 是如何实现事务？

InnoDB 实现事务 -> ACID：使用这三个日志 + 锁（排他锁/共享锁）

原子性：undo log(回滚日志)：记录数据修改前的状态，万一回滚恢复之前的状态

一致性：redo log(重做日志)：记录数据修改后的状态

隔离性：锁（行级锁、表锁），可分共享锁、排他锁

持久性：undo log(回滚日志) + redo log(重做日志)

binlog 文件是什么？存储的数据形式有哪些？有什么优缺？

bin log(二进制日志文件)，只记录对数据的修改操作，主要是主从复制和增量恢复

MySQL binlog 日志三种格式？

  1. Statement：每一条会修改的 SQL 都会记录到 binlog 中

（优点：减少日志量 - 缺点：主从复制中，带有特定函数的 SQL，从库执行可能出现不一致问题）

  1. Row：不记录 SQL 语句上下文信息，仅保存哪条记录被修改成什么样

（优点：不需要记录 SQL 的上下文信息，以每行记录的修改来记录，解决 SQL 带有特定函数的问题

缺点：biglog 日志量大（update 多条，每一条修改都会记录））

  1. Mixedlevel：以上两种 level 混合使用

[一般语句的修改使用 Statement 格式保存，一些函数无法则使用 Row 格式]

会根据每一条具体的 SQL 语句来区分记录的日志形式

MySQL 主从复制怎么实现？

binlog 线程、io 线程、sql 线程

1.binlog dump 线程将主服务器上的数据更改写入二进制文件（Binary log）

2.io 线程负责从主服务器中读取 binlog，并写入从服务器的中继日志（Relay log）

3.sql 线程读取中继日志，解析主服务器已执行的数据修改，并在从服务器进行重放（Replay）

MySQL 的 crash-safe 怎么实现的？？

三个日志+WAL+2PC

https://cloud.tencent.com/developer/article/1631999

为什么需要分库分表？

数据量太大，查询效率低下

怎样分库分表？

垂直拆分：按照业务（订单、商品）放在不同数据库，独立出来，就算一个业务出错不影响另一个业务，提高并发

缺点：无法解决单表数据越来越大的问题

水平拆分：将单表数据拆分多表，甚至放在不同库当中。按照日期时间划分、按照 hash 取模划分

采用 Apace sharding-jdbc 来作分库分表中间件

注意⚠️！需要做不同纬度的数据冗余，方便根据不同纬度的查询（空间换时间的方式）

索引优化有哪些？（哪些情况下索引会失效？）

只针对频繁查询的字段 设置索引

可以使用覆盖索引

避免索引失效（使用全值匹配、符合最左前缀原则[中间索引不能断]）

失效：

where 条件后用函数、运算符

模糊查询 like’%冰’（使用通配符开头）

不符合最左原则的联合索引

索引字段上!= <>这样会导致索引失效（is NULL / is not NULL）

索引 case！！！注意⚠️

联合索引（a、b、c）

a = ” and b = ” and c = ”（全都命中索引）

c = ” and b = ” and a = ”（全都命中索引，有 SQL 优化器）[连接器、查询缓存、分析器、优化器、执行器]

a = ” and c = ”（只有 a 命中，因为 b 没有，联合索引中间索引无）

a = ” and b > ” and c = ”（只有 a 和 b 命中，因为 b 时一个范围值，算是断点）

如果联合索引中有主键 a

b = ” and a = ” （只会走主键 a，因为 B+ 树索引结构）

Where 和 Order by 索引字段

使用联合索引 idx（a,b）

//可以走索引idx
where a = "xx" order by b

Mysql 的 order by 会根据创建联合索引顺序进行排序 且 asc

https://stackoverflow.com/questions/9641463/mysql-not-using-index-for-order-by/38071094

Redis

Redis 的五大基本类型？

  • String
  • List
  • Set
  • SortSet
  • Hash

SortSet 底层数据结构是怎么存储的？

有两种数据结构：压缩表 ziplist 和跳表 skiplist

  • 压缩表（如果有序保存元素数<128 || 长度<64byte）

  • skiplist 按序保存元素分值，使用 dict 来保存分值和元素的对应关系（有序链表 + 多级索引结构（关键节点））

    时间复杂度：O(logN) 空间复杂度：O(N)

跳表插入数据

1.新节点和各层索引节点逐一比较，确定原链表的插入位置。O（logN）

2.把索引插入到原链表。O（1）

3.利用抛硬币的随机方式，决定新节点是否提升为上一级索引。

结果为“正”则提升并继续抛硬币，结果为“负”则停止。O（logN）

总体上，跳跃表插入操作的时间复杂度是 O（logN），而这种数据结构所占空间是 2N，既空间复杂度是 O（N）。

跳表删除数据

1.自上而下，查找第一次出现节点的索引，并逐层找到每一层对应的节点 O(logN)

2.删除每一层查找到的节点，如果该层只有一个节点，删除整一层（除去原链表之外）O(logN)

总体来说，删除 O(logN)

如何解决 Redis 存储 String 类型大的 JSON 数据格式的问题？

可以使用中间件，对大的 JSON 字符串格式数据进行压缩

Redis 的过期时间是怎么实现的？

RedisDB 中有 Expires 字典保存 DB 中所有 key 的过期时间（过期字典）

键是一个指针指向数据库键

值是一个 long 类型的毫秒 unix 时间戳

判断 key -> 找过期字典 -> 判断现在 unix 时间戳是否大于 key 的 value

Redis 的过期键删除策略有哪些（三种）分别是怎样，优缺点

定时删除：key 一旦到达过期时间，立马删除

惰性删除：当 getKey 的时候，发现已到过期时间就删除返回 nil

定期删除：每隔一段时间，扫描过期 key，进行删除

定时删除：对内存友好，但对 CPU 时间不友好[降低服务器吞吐量和响应时间]

惰性删除：对内存不友好，大量过期的 key 放在 DB 中一直不被删除

定期删除：前两者折中方式，每隔一段时间执行删除过期 key 操作，限制删除 key 执行时长和频率

惰性删除：通过读写 DB 之前执行 expireIfNeeded 函数对输入 key 检查（过滤器）

定期删除：调用 activeExpireCycle 函数 在规定时间内分多次遍历服务器中各个数据库，从数据库 Expires 字典中随机检查一部分键的过期时间，过期则删除。

Redis 的持久化机制会有哪些（两种）分别是怎样的，优缺点

RDB：对数据生成快照方式，保存键值对记录数据库，存储二进制的 RDB 文件（可设置每隔一段时间进行 save）

AOF：保存对 Redis 执行写的操作命令，通过追加 append 方式添加命令

AOP 可以设置同步参数，一秒同步，redis 宕机最多丢失一秒前数据

如果需要对大规模数据进行恢复，对于数据完整性不是非常敏感，RDB 对 AOF 更加高效

对数据量较大的进行 RDB 持久化，没法做到秒级来 save/bgsave

反之，对数据完整性敏感性十足，使用 AOF，做到最多丢失一秒之前的 redis 数据

AOF 重写是怎样的？

Redis 通过创建一个新的 AOF 文件来替换现在的 AOF 文件（新旧文件保存 DB 状态相同）

不读取现有的 AOF 文件，而直接读取服务器当前 DB 的键现在的值，然后用一条命令记录 代替之前多条命令

首先从数据库中读取键现在的值，然后用一条命令去记录键值对，代替之前记录这个键值对的多条命令，这就是 AOF 重写功能的实现原理。

为了不影响处理其他命令请求，将 AOF 重写交给子进程（带有 Master 进程的副本，避免使用锁，保证数据安全）

AOF 重写期间服务器进行命令处理，导致数据不一致怎么办？

Redis 创建一个 AOF 重写缓冲区，在创建子进程后使用

AOF 重写期间，服务器进程工作：

  1. 执行客户端命令

  2. 将执行后命令追加 AOF 缓冲区

  3. 将执行命令追加 AOF 重写缓冲区

    当子进程完成 AOF 重写后，向父进程发信号，父进程接收到将 AOF 重写缓冲区中所有内容写入新 AOF 文件中

    再进行新的 AOF 改名 原子性覆盖现有的 AOF 文件，完成替换

AOF、RDB 和复制功能对过期键的处理？

RDB

  • 生成 RDB 文件：创建 RDB 文件，对数据库中 key 检查，会忽略过期键，只保存有用的 key

  • 载入 RDB 文件：（但主从服务器进行 RDB 文件载入，主会忽略，从会加载已过期 key 进去）

AOF

  • AOF 文件写入：AOF 会追加 append 该 key 被删除的 del 命令到 AOF 文件中

  • AOF 重写：和生成 RDB 文件一样，对 DB 中 key 检查，已过期的不会保存

为什么 Redis 支持高并发量，速度快？

  1. Redis 是内存型 DB，直接对内存读写速度快

  2. Redis 使用 io 多路复用，可以处理并发请求，采用 epoll 单线程轮询多个 socket 方式，处理事件。

（非阻塞 io 采用 epoll，读、写、关闭、连接转化成事件，减少 io 时间）

  1. Redis 是单线程的，io 多路处理的需要执行命令放在队列当中，单线程逐个执行，保证不会同时执行

避免产生多线程上下文切换，或者产生死锁等，性能消耗

  1. Redis 底层数据结构，压缩表、跳表、hash..高效的存取数据结构

  2. 采用 io 多路复用，监听多个客户端 socket，将 socket 事件放在队列当中，单线程处理

再交给文件事件分配器处理，分给不同的事件处理器进行处理（set、get、连接请求等处理）

select 和 epoll 的区别？阻塞 io 非阻塞 io io 多路复用 异步 io 分别？

  1. select、poll 用监视多个 socket 描述符，单线程轮询来判断数据是否就绪，就绪返回信号。还需要再一下轮询找到确定 socket 进行处理，而是 epoll 会把轮询已就绪的 socket 事件放在自己创建的链表中，epoll 只关心链表有无数据就可。

  2. epoll 不需要通过遍历的方式，而是在内核中建立了 file 节点，并且通过注册响应事件的方式，当有响应事件发生时采取相应的措施，并把准备就绪的事件放入链表中，从而 epoll 只关心链表中是否有数据即可。

  3. epoll 只需要一次拷贝就可以 其他 select 需要每次遍历过后在用户态 - 内核态中相互拷贝

Redis 分片有了解吗？

https://developer.aliyun.com/article/692428

Redis 主从复制？

https://www.cnblogs.com/kismetv/p/9236731.html

Redis 的高可用是怎么实现的？

  1. Redis 提供持久化机制、主从复制（读写分离）、集群 + 哨兵

  2. 持久化：针对于单机备份（从内存到磁盘）

  3. 主从复制：侧重在于多机的数据备份，实现读写分离、读的负载均衡和故障恢复

从节点保存主节点（masterhost 和 masterip）存储主节点的 ip 和 port 信息

从节点会每秒调用定时函数 replicationCron，发现主节点可以连接那就进行 socket 连接

从节点建立事件收集器，比如接收 RDB 文件、接收命令

集群 + 哨兵：

在复制基础上，哨兵解决自动化的故障恢复

  • 哨兵监控：不断检查主节点和从节点是否运行正常

  • 自动故障转移：当主节点不可用，升级其中一个从节点为主节点，其他从节点修改复制目标节点

  • 配置提供者：客户端连接时通过连接哨兵，拿到当前 redis 主节点的地址

  • 通知：哨兵会将故障转移的结果通知客户端

集群：通过集群，Redis 解决了写操作无法负载均衡，以及存储能力受到单机限制的问题，实现了较为完善的高可用方案。

Redis 的内存淘汰策略有哪些？

已设置过期时间的数据集 LRU 数据淘汰

已设置过期时间的数据集 即将过期的数据淘汰

已设置过期时间的数据集 选择任意数据淘汰

全局数据集 keys LRU 最近最少使用 key 淘汰

全局数据集 任意选择数据淘汰

禁止驱逐数据（满了存新的数据 直接报错）

Redis 中会出现哪些问题？（雪崩、击穿、穿透）

  1. 雪崩：keys 的过期时间设置随机数值

  2. 击穿（缓存 db 都没有的数据）：缓存空对象设置较短的过期时间（五分钟），或者使用 bitmap 设置布隆过滤器

（一定不存在的数据请求会直接过滤 无法打到 db）

  1. 穿透（热点数据缓存过期）：互斥锁，只要有一个请求访问来 DB 带来新的缓存，再释放锁

消息队列

RocketMQ 的实现原理是怎样？

RocketMQ 由 NameServer 提供服务注册、Product 生产者、Consumer 消费者、Broker（RocketMQ 进程）

  1. Broker 在启动时，向所有的 NameServe 注册，并保持长连接，每 30s 发送心跳

  2. Product 发送消息时，先从 NameServer 上获取 Broker 服务器地址，然后根据负载均衡算法选择一台服务器

来发送消息

  1. Consumer 消费消息时，从 NameServer 上获取 Broker 地址，然后主动拉取消息

RocketMQ 怎么实现这么高的吞吐量的（高可用）？

RocketMQ 分 Product、Consumer、Broker、Name Server

  1. 都是以集群的方式部署（可以支持多 master 模式、多 master 多 slave 异步复制模式、多 master 多 slave 同步双写模式）

  2. 支持 10 亿级别的消息堆积，不会因为堆积导致性能下降

  3. 支持海量的 topic

RocketMQ 怎么保证消息不丢失？

  1. producer 端 采用同步发送消息，回调获得发送结果是否 success

    发送失败，会发送重试（三次）

  2. broker 端

    设置同步刷盘（默认是异步刷盘）持久化采用 CommitLog 来落盘

    集群部署，主从模式，高可用（万一 master 挂，使用 slave 继续转发[master 接受到消息会同步 slave]）

  3. consumer 端

    at least once 消息消费会发 ack 确认给 broker

RocketMQ 的消费信息是以什么样的形式进行存储？

ByteBuffer msgStoreItemMemory

[存储编码后的消息，即将消息转换成字节的方式

和对象的序列化不同，不仅仅有消息体内容，还加上额外信息（消息创建时间、消息生产者的 host、消息体的长度、topic…）]

（需要查看源码确认）

RocketMQ 怎么保证消息不重复消费？

生产者没必要做幂等性

消费者端做好幂等性，确保重复的请求不会造成影响。

比如：判断 DB 是否消费，在数据库使用唯一索引，保证消息只被消费一次。

  1. 消费端处理消息的业务逻辑保持幂等性
  2. 保证每条消息都有唯一编号且保证消息处理成功和去重表的日志同时出现

RocketMQ 怎么保证消息的有序性（顺序消费）？

同一 topic，同一个 queue，发消息的时候一个线程去发送消息，消费的时候 一个线程去消费一个 queue 里的消息

2021.11 补充：

消费者的消费 queue 和协程关系是怎么的？一对一还是多？无序和有序消费区别是什么？

顺序消费是每个 queue 分配一个协程去处理，比如 workerA 从 queue1 中拉取，会放在 buffer 中

  • 虽然是 messageBuffer 数组，但无序对应是一个同一个 messageChan（存放 message）

    无序：每个协程对应是同一个 messageBuffer

    有序：每个协程对应不同的 messageBuffer

名称\比例消息 queuemessageBuffer协程 worker
无序 disOrderlyn1n
有序 orderlynnn

多个协程怎么分配到对应的 message，进行获取对应消息进行消费？

无论无序消费还是有序消费，都是从协程分配的 messageBuffer 从获取 message 进行处理

  • 不同之处：
    1. 无序，就算消费组重启需要变更，rebalance，需要给多个 queue（消息）重新分配对应的协程，但多个协程对应还是同一个 buffer，消息继续发，可能其他协程停了，但其他协程继续直接拿来就消费。
    2. 有序，则多个协程序对应多个 buffer，可能有协程停了，对应的 buffer channel 没法消费，持续积压，只有 rebalance 完分配了新协程就可以继续消费，消费速度降低，会导致积压上升。

同个 comsumer 对应多个协程从自己对应的 messageBuffer 获取 message 消费，是跟拿取的一样并发消费的吗（有序无序）？

  • 源码中，并发的开多协程从 buffer 获取消息，然后各个协程消费 buffer channel，说明协程也是并发消费消息，消息分发到各个协程当中，互不影响一起消费。
  • 感觉看作每个协程消费也是一个队列，多个队列并发消费。

有序如何设置无限重试的？设置 retryTime 控制次数可不可以？

可以（两个条件是或者的关系）

一个 topic 下有多个队列，为了保证有序，RocketMQ 提供了 MessageQueueSelector 队列选择机制

我们可使用 Hash 取模法，让同一个订单发送到同一个队列中，再使用同步发送，只有同个订单的创建消息发送成功，再发送支付消息。这样，我们保证了发送有序。【在同个队列中消息是有序】

RocketMQ 仅保证顺序发送，顺序消费由消费者业务保证!!!（消费端幂等性）

生产者顺序发送，消费者顺序消费 setOrderly = true

计算机网络

OSI 七层模型

应用层 表示层 会话层 传输层 网络层 数据链路层 物理层

TCP/IP四层体系模型？

应用层、传输层、网际层、网络接口层

TCP/IP（参考）模型与OSI七层模型有什么异同？

OSI 七层模型是站在完整、宏观纬度上计算机网络分层

TCP/IP四层模型是围绕TCP/IP网络中通信协议来进行分层

HTTP 基本组成？

header + body

HTTP 常见字段有哪些？

Host 字段（服务器域名）

Content-length（服务端返回的数据长度）

Content-type（服务端回应，告诉客户端这次数据是什么格式，text/html; charset=utf-8）

Content-Encoding：gzip（服务端返回数据是什么压缩格式）

Connection（客户端要求服务器 TCP 持久连接，请求复用 keep-alive）

HTTP 常见的状态码有哪些？

200 请求 ok

301 永久重定向

302 临时重定向

400 bad request 客户端请求报文有误

404 not found 客户端请求资源服务端不存在

403 forbidden 客户端无权限访问资源

500 内部服务器错误

502 bad gatway 服务端作为网关或者代理时返回错误码

503 服务器忙，无法回应

301 302 状态码的区别？

301 永久重定向

302 临时重定向

HTTP 有哪些请求操作？分别

get、post、put、delete、head、options、patch

Get 和 Post 区别

HTTP 哪些请求是安全和幂等的？

get head options

HTTP 的优缺点分别是？

明文传输（易窃听）

无法验证通信双方的身份（易伪装）

无法证明报文的完整性（易篡改）

为什么 HTTP 是无状态的？

使用无状态的，应对大量的请求只需要来了服务端接收请求，处理完断开连接。

减轻服务端设计，不然每个访问网站的用户，服务器都要保存他们信息，是服务器负担

cookie 和 session？

HTTP 和 HTTPS 有什么区别？

什么是对称加密/非对称加密？

HTTPS 怎么加密的 (混合加密)？

TCP 的三次握手、四次挥手过程是怎样？

为什么说 TCP 是可靠的？（超时重传）

TCP 的流量控制、拥塞控制是怎样实现？（丢包）

（慢开始、拥塞避免、快重传、快恢复）

发送方维护一个拥塞窗口（cwnd）状态变量

慢开始：发送的报文数令 cwnd=1，发送方只能发送一个报文段；当收到确认后，将 cwnd 加倍

2、4、8、16…（报文段数量）

拥塞避免：设置了（阈值）ssthresh，当 cwnd >= ssthresh，进入拥塞避免，每轮只将 cwnd + 1

超时情况：如果出现了超时，将 ssthresh = cwnd/2，重新执行 -> 慢启动

快重传：接收方每次接收到报文段，都会对最后一个有序报文段进行确认。ex：已收到 M1、M2、现在接收到 M4，

应当对 M2 进行确认。发送方接收到三次重复的确认，就知道下一个报文段丢失，立即快重传 M3

属于个别报文段丢失，执行快恢复，ssthresh = cwnd/2，cwnd = ssthresh，直接进入拥塞避免

TCP 和 UDP 的区别？

使用 TCP、UDP 的例子？

什么是 ARP 协议

什么是 ICMP 协议

什么是 DNS

什么 DHCP

海量数据场景问题

bitMap

使用最小堆

spring 三级缓存

cms 和 g1 垃圾收集器

操作系统

进程的几种状态

https://www.jianshu.com/p/ac9ce2afd126

就绪、进行、阻塞

线程的几种状态

https://blog.csdn.net/pange1991/article/details/53860651

https://www.liaoxuefeng.com/wiki/1252599548343744/1306580742045730

  • New：新创建的线程，尚未执行；

  • Runnable：运行中的线程，正在执行run()方法的 Java 代码；

  • Blocked：运行中的线程，因为某些操作被阻塞而挂起；

  • Waiting：运行中的线程，因为某些操作在等待中；

  • Timed Waiting：运行中的线程，因为执行sleep()方法正在计时等待；

  • Terminated：线程已终止，因为run()方法执行完毕。

输入 url 到返回数据有用到哪些协议？

DNS 协议、TCP 协议、IP 协议、ARP 协议、HTTP 协议

过程？

DNS 解析、TCP 连接、发送 HTTP 请求、服务端处理请求返回 HTTP 报文、浏览器解析渲染、连接结束

Mysql explain 各字段解释

https://juejin.cn/post/6850418120998256654

https://blog.csdn.net/argleary/article/details/104189850

线程池

  • 有哪些参数？怎么设置？工作机制？

  • 拒绝策略有哪些？

核心线程数、最大线程数、空闲时间存活时间、存活时间单位 unit、阻塞队列、拒绝策略

拒绝策略：静默丢弃、直接抛异常、交给调用方处理、丢弃队伍中最老的任务

2021/04/19有感
Java 基础知识点归纳