Java八股文面试全套真题_java八股文面试题

一、Redis

1.1、你在最近的项目中哪些场景使用了redis呢？

一是验证你的项目场景的真实性，二是为了作为深入发问的切入点。

缓存

• 缓存三兄弟（穿透、击穿、雪崩）、双写一致、持久化、数据过期策略，数据淘汰策略

分布式锁

• setnx、redisson

消息队列、延迟队列

• 何种数据类型

1.2、缓存穿透

缓存穿透是指查询一个一定不存在的数据，如果从存储层查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到 DB 去查询，可能导致 DB 挂掉。这种情况大概率是遭到了攻击。

解决方案一：缓存空数据，查询返回的数据为空，仍把这个空结果进行缓存

{key:1,value:null}
1

优点： 简单

缺点： 消耗内存，可能会发生不一致的问题

解决方案二：布隆过滤器

优点： 内存占用较少，没有多余key

缺点： 实现复杂，存在误判

1.3、布隆过滤器

bitmap（位图）： 相当于是一个以（bit）位为单位的数组，数组中每个单元只能存储二进制数0或1。

布隆过滤器主要是用于检索一个元素是否在一个集合中。我们当时使用的是redisson实现的布隆过滤器。

它的底层主要是先去初始化一个比较大数组，里面存放的二进制0或1。在一开始都是0，当一个key来了之后经过3次hash计算，模于数组长度找到数据的下标然后把数组中原来的0改为1，这样的话，三个数组的位置就能标明一个key的存在。查找的过程也是一样的。

当然是有缺点的，布隆过滤器有可能会产生一定的误判，我们一般可以设置这个误判率，大概不会超过5%，其实这个误判是必然存在的，要不就得增加数组的长度，其实已经算是很划分了，5%以内的误判率一般的项目也能接受，不至于高并发下压倒数据库。

误判率：数组越小误判率就越大，数组越大误判率就越小，但是同时带来了更多的内存消耗。

1.4、缓存击穿

缓存击穿的意思是对于设置了过期时间的key，缓存在某个时间点过期的时候，恰好这时间点对这个Key有大量的并发请求过来，这些请求发现缓存过期一般都会从后端 DB 加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把 DB 压垮。

解决方案有两种方式：

• 使用互斥锁：当缓存失效时，不立即去load db，先使用如 Redis 的 setnx 去设置一个互斥锁，当操作成功返回时再进行 load db的操作并回设缓存，否则重试get缓存的方法。

• 可以设置当前key逻辑过期，大概是思路如下：

  • 在设置key的时候，设置一个过期时间字段一块存入缓存中，不给当前key设置过期时间
  • 当查询的时候，从redis取出数据后判断时间是否过期
  • 如果过期则开通另外一个线程进行数据同步，当前线程正常返回数据，这个数据不是最新

两种方案各有利弊

• 如果选择数据的强一致性，建议使用分布式锁的方案，性能上可能没那么高，锁需要等，也有可能产生死锁的问题
• 如果选择key的逻辑删除，则优先考虑的高可用性，性能比较高，但是数据同步这块做不到强一致。

1.5、缓存雪崩

缓存雪崩意思是设置缓存时采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到DB，DB 瞬时压力过重雪崩。与缓存击穿的区别：雪崩是很多key，击穿是某一个key缓存。

解决方案：

给不同的Key的TTL添加随机值

• 将缓存失效时间分散开，比如可以在原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。

利用Redis集群提高服务的可用性

• 哨兵模式、集群模式

给缓存业务添加降级限流策略

• ngxin或spring cloud gateway

给业务添加多级缓存

• Guava或Caffeine

缓存三兄弟

穿透无中生有key，布隆过滤null隔离。

缓存击穿过期key， 锁与非期解难题。

雪崩大量过期key，过期时间要随机。

面试必考三兄弟，可用限流来保底。

1.6、redis做为缓存，mysql的数据如何与redis进行同步呢？（双写一致性）

双写一致： 当修改了数据库的数据也要同时更新缓存的数据，缓存和数据库的数据要保持一致

1.6.1、读操作

缓存命中，直接返回；缓存未命中查询数据库，写入缓存，设定超时时间

有脏数据风险

1.6.2、写操作：延迟双删

代码耦合性高

1.6.3、异步通知保证数据的最终一致性

1.6.4、基于Canal的异步通知

二进制日志（BINLOG）记录了所有的 DDL（数据定义语言）语句和 DML（数据操纵语言）语句，但不包括数据查询（SELECT、SHOW）语句。

1.6.5、参考回答

最近做的这个项目，里面有xxxx（根据自己的简历上写）的功能，需要让数据库与redis高度保持一致，因为要求时效性比较高，我们当时采用的读写锁保证的强一致性。

我们采用的是redisson实现的读写锁，在读的时候添加共享锁，可以保证读读不互斥，读写互斥。当我们更新数据的时候，添加排他锁，它是读写，读读都互斥，这样就能保证在写数据的同时是不会让其他线程读数据的，避免了脏数据。这里面需要注意的是读方法和写方法上需要使用同一把锁才行。

1.6.6、那这个排他锁是如何保证读写、读读互斥的呢？

其实排他锁底层使用也是setnx，保证了同时只能有一个线程操作锁住的方法

1.6.7、你听说过延时双删吗？为什么不用它呢？

延迟双删，如果是写操作，我们先把缓存中的数据删除，然后更新数据库，最后再延时删除缓存中的数据，其中这个延时多久不太好确定，在延时的过程中可能会出现脏数据，并不能保证强一致性，所以没有采用它。

1.6.8、数据同步可以有一定的延时（符合大部分业务）

我们当时采用的阿里的canal组件实现数据同步：不需要更改业务代码，部署一个canal服务。canal服务把自己伪装成mysql的一个从节点，当mysql数据更新以后，canal会读取binlog数据，然后在通过canal的客户端获取到数据，更新缓存即可。

1.7、数据持久化

在Redis中提供了两种数据持久化的方式：

RDB

• RDB是一个快照文件，它是把redis内存存储的数据写到磁盘上，当redis实例宕机恢复数据的时候，方便从RDB的快照文件中恢复数据。

AOF

• AOF的含义是追加文件，当redis操作写命令的时候，都会存储这个文件中，当redis实例宕机恢复数据的时候，会从这个文件中再次执行一遍命令来恢复数据。

1.7.1、这两种方式，哪种恢复的比较快呢？

RDB因为是二进制文件，在保存的时候体积也是比较小的，它恢复的比较快，但是它有可能会丢数据，我们通常在项目中也会使用AOF来恢复数据，虽然AOF恢复的速度慢一些，但是它丢数据的风险要小很多，在AOF文件中可以设置刷盘策略，我们当时设置的就是每秒批量写入一次命令。

1.7.2、 RDB的执行原理

bgsave开始时会fork主进程得到子进程，子进程共享主进程的内存数据。完成fork后读取内存数据并写入 RDB 文件。

fork采用的是copy-on-write技术：

• 当主进程执行读操作时，访问共享内存；
• 当主进程执行写操作时，则会拷贝一份数据，执行写操作。

1.7.3、AOF

AOF全称为Append Only File（追加文件）。Redis处理的每一个写命令都会记录在AOF文件，可以看做是命令日志文件。

AOF默认是关闭的，需要修改redis.conf配置文件来开启AOF：

# 是否开启AOF功能，默认是no
appendonly yes
# AOF文件的名称
appendfilename "appendonly.aof"
1
2
3
4

AOF的命令记录的频率也可以通过redis.conf文件来配：

# 表示每执行一次写命令，立即记录到AOF文件
appendfsync always 
# 写命令执行完先放入AOF缓冲区，然后表示每隔1秒将缓冲区数据写到AOF文件，是默认方案
appendfsync everysec 
# 写命令执行完先放入AOF缓冲区，由操作系统决定何时将缓冲区内容写回磁盘
appendfsync no
1
2
3
4
5
6

因为是记录命令，AOF文件会比RDB文件大的多。而且AOF会记录对同一个key的多次写操作，但只有最后一次写操作才有意义。通过执行bgrewriteaof命令，可以让AOF文件执行重写功能，用最少的命令达到相同效果。

Redis也会在触发阈值时自动去重写AOF文件。阈值也可以在redis.conf中配置：

# AOF文件比上次文件 增长超过多少百分比则触发重写
auto-aof-rewrite-percentage 100
# AOF文件体积最小多大以上才触发重写 
auto-aof-rewrite-min-size 64mb 
1
2
3
4

1.7.4、RDB与AOF对比

RDB和AOF各有自己的优缺点，如果对数据安全性要求较高，在实际开发中往往会结合两者来使用。

1.8、假如redis的key过期之后，会立即删除吗？

Redis对数据设置数据的有效时间，数据过期以后，就需要将数据从内存中删除掉。可以按照不同的规则进行删除，这种删除规则就被称之为数据的删除策略（数据过期策略）。

1.9、Redis的数据过期策略有哪些

1.9.1、Redis数据删除策略-惰性删除

惰性删除：设置该key过期时间后，我们不去管它，当需要该key时，我们在检查其是否过期，如果过期，我们就删掉它，反之返回该key

优点 ：对CPU友好，只会在使用该key时才会进行过期检查，对于很多用不到的key不用浪费时间进行过期检查

缺点 ：对内存不友好，如果一个key已经过期，但是一直没有使用，那么该key就会一直存在内存中，内存永远不会释放

1.9.2、Redis数据删除策略-定期删除

定期删除：每隔一段时间，我们就对一些key进行检查，删除里面过期的key(从一定数量的数据库中取出一定数量的随机key进行检查，并删除其中的过期key)。

定期清理有两种模式：

• SLOW模式是定时任务，执行频率默认为10hz，每次不超过25ms，以通过修改配置文件redis.conf 的hz 选项来调整这个次数

• FAST模式执行频率不固定，但两次间隔不低于2ms，每次耗时不超过1ms

优点：可以通过限制删除操作执行的时长和频率来减少删除操作对 CPU 的影响。另外定期删除，也能有效释放过期键占用的内存。

缺点：难以确定删除操作执行的时长和频率。

Redis的过期删除策略：惰性删除 + 定期删除两种策略进行配合使用

1.10、redis的数据淘汰策略

当Redis中的内存不够用时，此时在向Redis中添加新的key，那么Redis就会按照某一种规则将内存中的数据删除掉，这种数据的删除规则被称之为内存的淘汰策略。

Redis支持8种不同策略来选择要删除的key：

• unoeviction： 不淘汰任何key，但是内存满时不允许写入新数据，默认就是这种策略。
• uvolatile-ttl： 对设置了TTL的key，比较key的剩余TTL值，TTL越小越先被淘汰
• uallkeys-random：对全体key ，随机进行淘汰。
• uvolatile-random：对设置了TTL的key ，随机进行淘汰。
• uallkeys-lru： 对全体key，基于LRU算法进行淘汰
• uvolatile-lru： 对设置了TTL的key，基于LRU算法进行淘汰
• uallkeys-lfu： 对全体key，基于LFU算法进行淘汰
• uvolatile-lfu： 对设置了TTL的key，基于LFU算法进行淘汰

LRU（Least Recently Used）最近最少使用。用当前时间减去最后一次访问时间，这个值越大则淘汰优先级越高。

LFU（Least Frequently Used）最少频率使用。会统计每个key的访问频率，值越小淘汰优先级越高。

1.10.1、数据淘汰策略-使用建议

1. 优先使用 allkeys-lru 策略。充分利用 LRU 算法的优势，把最近最常访问的数据留在缓存中。如果业务有明显的冷热数据区分，建议使用。

2. 如果业务中数据访问频率差别不大，没有明显冷热数据区分，建议使用 allkeys-random，随机选择淘汰。

3. 如果业务中有置顶的需求，可以使用 volatile-lru 策略，同时置顶数据不设置过期时间，这些数据就一直不被删除，会淘汰其他设置过期时间的数据。

4. 如果业务中有短时高频访问的数据，可以使用 allkeys-lfu 或 volatile-lfu 策略。

1.10.2、关于数据淘汰策略其他的面试问题

1. 数据库有1000万数据 ,Redis只能缓存20w数据, 如何保证Redis中的数据都是热点数据 ?

   使用allkeys-lru(挑选最近最少使用的数据淘汰)淘汰策略，留下来的都是经常访问的热点数据

2. Redis的内存用完了会发生什么？

   主要看数据淘汰策略是什么？如果是默认的配置（ noeviction ），会直接报错。

1.11、redis分布式锁

在redis中提供了一个命令setnx(SET if not exists)，由于redis的单线程的，用了命令之后，只能有一个客户端对某一个key设置值，在没有过期或删除key的时候是其他客户端是不能设置这个key的

1.11.1、如何控制Redis实现分布式锁有效时长

redis的setnx指令不好控制这个问题，我们当时采用的redis的一个框架redisson实现的。

在redisson中需要手动加锁，并且可以控制锁的失效时间和等待时间，当锁住的一个业务还没有执行完成的时候，在redisson中引入了一个看门狗机制，就是说每隔一段时间就检查当前业务是否还持有锁，如果持有就增加加锁的持有时间，当业务执行完成之后需要使用释放锁就可以了

还有一个好处就是，在高并发下，一个业务有可能会执行很快，先客户1持有锁的时候，客户2来了以后并不会马上拒绝，它会自旋不断尝试获取锁，如果客户1释放之后，客户2就可以马上持有锁，性能也得到了提升。

1.11.2、redisson实现的分布式锁是可重入的吗？

嗯，是可以重入的。这样做是为了避免死锁的产生。这个重入其实在内部就是判断是否是当前线程持有的锁，如果是当前线程持有的锁就会计数，如果释放锁就会在计算上减一。在存储数据的时候采用的hash结构，大key可以按照自己的业务进行定制，其中小key是当前线程的唯一标识，value是当前线程重入的次数。

1.11.3、redisson实现的分布式锁能解决主从一致性的问题吗

这个是不能的，比如，当线程1加锁成功后，master节点数据会异步复制到slave节点，此时当前持有Redis锁的master节点宕机，slave节点被提升为新的master节点，假如现在来了一个线程2，再次加锁，会在新的master节点上加锁成功，这个时候就会出现两个节点同时持有一把锁的问题。

我们可以利用redisson提供的红锁来解决这个问题，它的主要作用是，不能只在一个redis实例上创建锁，应该是在多个redis实例上创建锁，并且要求在大多数redis节点上都成功创建锁，红锁中要求是redis的节点数量要过半。这样就能避免线程1加锁成功后master节点宕机导致线程2成功加锁到新的master节点上的问题了。

但是，如果使用了红锁，因为需要同时在多个节点上都添加锁，性能就变的很低了，并且运维维护成本也非常高，所以，我们一般在项目中也不会直接使用红锁，并且官方也暂时废弃了这个红锁

1.11.4、如果业务非要保证数据的强一致性，这个该怎么解决呢？

redis本身就是支持高可用的，做到强一致性，就非常影响性能，所以，如果有强一致性要求高的业务，建议使用zookeeper实现的分布式锁，它是可以保证强一致性的。

1.12、Redis集群

在Redis中提供的集群方案总共有三种：主从复制、哨兵模式、Redis分片集群

1.12.1、主从复制

单节点Redis的并发能力是有上限的，要进一步提高Redis的并发能力，就需要搭建主从集群，实现读写分离。

1.12.2、主从同步原理

分为了两个阶段

• 全量同步
• 增量同步

全量同步

Replication Id：简称replid，是数据集的标记，id一致则说明是同一数据集。每一个master都有唯一的replid，slave则会继承master节点的replid。
offset：偏移量，随着记录在repl_baklog中的数据增多而逐渐增大。slave完成同步时也会记录当前同步的offset。如果slave的offset小于master的offset，说明slave数据落后于master，需要更新。

全量同步是指从节点第一次与主节点建立连接的时候使用全量同步，流程是这样的：

1. 从节点请求主节点同步数据，其中从节点会携带自己的replication id和offset偏移量。

2. 主节点判断是否是第一次请求，主要判断的依据就是，主节点与从节点是否是同一个replication id，如果不是，就说明是第一次同步，那主节点就会把自己的replication id和offset发送给从节点，让从节点与主节点的信息保持一致。

3. 在同时主节点会执行bgsave，生成rdb文件后，发送给从节点去执行，从节点先把自己的数据清空，然后执行主节点发送过来的rdb文件，这样就保持了一致

当然，如果在rdb生成执行期间，依然有请求到了主节点，而主节点会以命令的方式记录到缓冲区，缓冲区是一个日志文件，最后把这个日志文件发送给从节点，这样就能保证主节点与从节点完全一致了，后期再同步数据的时候，都是依赖于这个日志文件，这个就是全量同步。

增量同步

slave重启或后期数据变化

增量同步指的是，当从节点服务重启之后，数据就不一致了，所以这个时候，从节点会请求主节点同步数据，主节点还是判断不是第一次请求，不是第一次就获取从节点的offset值，然后主节点从命令日志中获取offset值之后的数据，发送给从节点进行数据同步

1.13、哨兵

Redis提供了哨兵（Sentinel）机制来实现主从集群的自动故障恢复。哨兵的结构和作用如下：

• 监控：Sentinel 会不断检查您的master和slave是否按预期工作

• 自动故障恢复：如果master故障，Sentinel会将一个slave提升为master。当故障实例恢复后也以新的master为主

• 通知：Sentinel充当Redis客户端的服务发现来源，当集群发生故障转移时，会将最新信息推送给Redis的客户端

服务状态监控

Sentinel基于心跳机制监测服务状态，每隔1秒向集群的每个实例发送ping命令：

• 主观下线：如果某sentinel节点发现某实例未在规定时间响应，则认为该实例主观下线。

• 客观下线：若超过指定数量（quorum）的sentinel都认为该实例主观下线，则该实例客观下线。quorum值最好超过Sentinel实例数量的一半。

哨兵选主规则

• 首先判断主与从节点断开时间长短，如超过指定值就排该从节点
• 然后判断从节点的slave-priority值，越小优先级越高
• 如果slave-prority一样，则判断slave节点的offset值，越大优先级越高
• 最后是判断slave节点的运行id大小，越小优先级越高。

1.14、怎么保证Redis的高并发高可用

首先可以搭建主从集群，再加上使用redis中的哨兵模式，哨兵模式可以实现主从集群的自动故障恢复，里面就包含了对主从服务的监控、自动故障恢复、通知；如果master故障，Sentinel会将一个slave提升为master。当故障实例恢复后也以新的master为主；同时Sentinel也充当Redis客户端的服务发现来源，当集群发生故障转移时，会将最新信息推送给Redis的客户端，所以一般项目都会采用哨兵的模式来保证redis的高并发高可用

1.15、redis是单点还是集群，哪种集群

我们当时使用的是主从（1主1从）加哨兵。一般单节点不超过10G内存，如果Redis内存不足则可以给不同服务分配独立的Redis主从节点。尽量不做分片集群。因为集群维护起来比较麻烦，并且集群之间的心跳检测和数据通信会消耗大量的网络带宽，也没有办法使用lua脚本和事务。

1.16、redis集群脑裂，该怎么解决呢？

这个在项目很少见，不过脑裂的问题是这样的，我们现在用的是redis的哨兵模式集群的

有的时候由于网络等原因可能会出现脑裂的情况，就是说，由于redis master节点和redis salve节点和sentinel处于不同的网络分区，使得sentinel没有能够心跳感知到master，所以通过选举的方式提升了一个salve为master，这样就存在了两个master，就像大脑分裂了一样，这样会导致客户端还在old master那里写入数据，新节点无法同步数据，当网络恢复后，sentinel会将old master降为salve，这时再从新master同步数据，这会导致old master中的大量数据丢失。

解决方式，在redis配置中设置

• 设置最少的salve节点个数，比如设置至少要有一个从节点才能同步数据，
• 设置主从数据复制和同步的延迟时间，达不到要求就拒绝请求，就可以避免大量的数据丢失。

1.17、分片集群结构

主从和哨兵可以解决高可用、高并发读的问题。但是依然有两个问题没有解决：

• 海量数据存储问题
• 高并发写的问题

使用分片集群可以解决上述问题，分片集群特征：

• 集群中有多个master，每个master保存不同数据
• 每个master都可以有多个slave节点
• master之间通过ping监测彼此健康状态
• 客户端请求可以访问集群任意节点，最终都会被转发到正确节点

1.17.1、 redis的分片集群有什么作用

分片集群主要解决的是，海量数据存储的问题，集群中有多个master，每个master保存不同数据，并且还可以给每个master设置多个slave节点，就可以继续增大集群的高并发能力。同时每个master之间通过ping监测彼此健康状态，就类似于哨兵模式了。当客户端请求可以访问集群任意节点，最终都会被转发到正确节点

1.17.2、 Redis分片集群中数据是怎么存储和读取的？

Redis 集群引入了哈希槽的概念，有 16384 个哈希槽，集群中每个主节点绑定了一定范围的哈希槽范围， key通过 CRC16 校验后对 16384 取模来决定放置哪个槽，通过槽找到对应的节点进行存储。

取值的逻辑是一样的

1.18、Redis是单线程的，但是为什么还那么快？

• 完全基于内存的，C语言编写

• 采用单线程，避免不必要的上下文切换可竞争条件

• 使用多路I/O复用模型，非阻塞IO

例如：bgsave 和 bgrewriteaof 都是在后台执行操作，不影响主线程的正常使用，不会产生阻塞

1.19、能解释一下I/O多路复用模型？

I/O多路复用是指利用单个线程来同时监听多个Socket ，并在某个Socket可读、可写时得到通知，从而避免无效的等待，充分利用CPU资源。目前的I/O多路复用都是采用的epoll模式实现，它会在通知用户进程Socket就绪的同时，把已就绪的Socket写入用户空间，不需要挨个遍历Socket来判断是否就绪，提升了性能。

其中Redis的网络模型就是使用I/O多路复用结合事件的处理器来应对多个Socket请求，比如，提供了连接应答处理器、命令回复处理器，命令请求处理器；

在Redis6.0之后，为了提升更好的性能，在命令回复处理器使用了多线程来处理回复事件，在命令请求处理器中，将命令的转换使用了多线程，增加命令转换速度，在命令执行的时候，依然是单线程。

例如：bgsave 和 bgrewriteaof 都是在后台执行操作，不影响主线程的正常使用，不会产生阻塞

二、MySQL

2.1、MySQL中，如何定位慢查询?

方案一：开源工具

• 调试工具：Arthas

• 运维工具：Prometheus 、Skywalking

方案二：MySQL自带慢日志

慢查询日志记录了所有执行时间超过指定参数（long_query_time，单位：秒，默认10秒）的所有SQL语句的日志。

如果要开启慢查询日志，需要在MySQL的配置文件（/etc/my.cnf）中配置如下信息：

# 开启MySQL慢日志查询开关
slow_query_log=1
# 设置慢日志的时间为2秒，SQL语句执行时间超过2秒，就会视为慢查询，记录慢查询日志
long_query_time=2
1
2
3
4

配置完毕之后，通过以下指令重新启动MySQL服务器进行测试，查看慢日志文件中记录的信息 /var/lib/mysql/localhost-slow.log。

2.2、一个SQL语句执行很慢, 如何分析

可以采用EXPLAIN或者DESC命令获取 MySQL 如何执行 SELECT 语句的信息

语法

-- 直接在select语句之前加上关键字 explain / desc
EXPLAIN   SELECT   字段列表   FROM 表名   WHERE  条件 ;
1
2

• possible_key 当前sql可能会使用到的索引

• key 当前sql实际命中的索引

• key_len 索引占用的大小

• Extra 额外的优化建议

• type 这条sql的连接的类型，性能由好到差为NULL、system、const、eq_ref、ref、range、 index、all
  • system：查询系统中的表
  • const：根据主键查询
  • eq_ref：主键索引查询或唯一索引查询
  • ref：索引查询
  • range：范围查询
  • index：索引树扫描
  • all：全盘扫描

参考回答

可以采用MySQL自带的分析工具 EXPLAIN

• 通过key和key_len检查是否命中了索引（索引本身存在是否有失效的情况）

• 通过type字段查看sql是否有进一步的优化空间，是否存在全索引扫描或全盘扫描

• 通过extra建议判断，是否出现了回表的情况，如果出现了，可以尝试添加索引或修改返回字段来修复

2.3、MYSQL支持的存储引擎有哪些, 有什么区别 ?

存储引擎就是存储数据、建立索引、更新/查询数据等技术的实现方式 。存储引擎是基于表的，而不是基于库的，所以存储引擎也可被称为表类型。

在mysql中提供了很多的存储引擎，比较常见有InnoDB、MyISAM、Memory

• InnoDB存储引擎是mysql5.5之后是默认的引擎，它支持事务、外键、表级锁和行级锁
• MyISAM是早期的引擎，它不支持事务、只有表级锁、也没有外键，用的不多
• Memory主要把数据存储在内存，支持表级锁，没有外键和事务，用的也不多

2.4、存储引擎在mysql的体系结构哪一层，主要特点是什么

2.4.1、MySQL体系结构

2.4.2、存储引擎特点

InnoDB是一种兼顾高可靠性和高性能的通用存储引擎，在 MySQL 5.5 之后，InnoDB是默认的MySQL存储引擎。

特点

• DML操作遵循ACID模型，支持事务。
• 行级锁，提高并发访问性能。
• 支持外键，FOREIGN KEY约束，保证数据的完整性和正确性。

文件

• xxx.ibd：xxx代表的是表名，innoDB引擎的每张表都会对应这样一个表空间文件，存储该表的表结构（frm、sdi）、数据和索引。
• xxx.frm 存储表结构（MySQL8.0时，合并在表名.ibd中）

2.5、什么是索引

索引在项目中还是比较常见的，它是帮助MySQL高效获取数据的数据结构，主要是用来提高数据检索的效率，降低数据库的IO成本，同时通过索引列对数据进行排序，降低数据排序的成本，也能降低了CPU的消耗。

2.6、索引的底层数据结构了解过嘛 ?

MySQL的默认的存储引擎InnoDB采用的B+树的数据结构来存储索引，选择B+树的主要的原因是：

• 阶数更多，路径更短，
• 磁盘读写代价B+树更低，非叶子节点只存储指针，叶子阶段存储数据，
• B+树便于扫库和区间查询，叶子节点是一个双向链表。

2.7、B树和B+树的区别

• 在B树中，非叶子节点和叶子节点都会存放数据，而B+树的所有的数据都会出现在叶子节点，在查询的时候，B+树查找效率更加稳定
• 在进行范围查询的时候，B+树效率更高，因为B+树都在叶子节点存储，并且叶子节点是一个双向链表。

B-Tree，B树是一种多叉路衡查找树，相对于二叉树，B树每个节点可以有多个分支，即多叉。

以一颗最大度数（max-degree）为5(5阶)的b-tree为例，那这个B树每个节点最多存储4个key

B+Tree是在BTree基础上的一种优化，使其更适合实现外存储索引结构，InnoDB存储引擎就是用B+Tree实现其索引结构

B树与B+树对比:

• 磁盘读写代价B+树更低
• 查询效率B+树更加稳定
• B+树便于扫库和区间查询

2.8、什么是聚簇索引什么是非聚簇索引 ?

聚集索引选取规则:

• 如果存在主键，主键索引就是聚集索引。
• 如果不存在主键，将使用第一个唯一（UNIQUE）索引作为聚集索引。
• 如果表没有主键，或没有合适的唯一索引，则InnoDB会自动生成一个rowid作为隐藏的聚集索引。

2.9、什么是回表查询

其实跟刚才介绍的聚簇索引和非聚簇索引是有关系的，回表的意思就是通过二级索引找到对应的主键值，然后再通过主键值找到聚集索引中所对应的整行数据，这个过程就是回表

备注：直接问回表，则需要先介绍聚簇索引和非聚簇索引

2.10、什么叫覆盖索引

覆盖索引是指查询使用了索引，并且需要返回的列，在该索引中已经全部能够找到 。

• id为主键，默认是主键索引
• name字段为普通索引

-- 覆盖索引
select * from tb_user where id = 2;

-- 覆盖索引
select id，name from tb_user where name = ‘Arm’;

-- 非覆盖索引(需要回表查询)
select id，name，gender from tb_user where name = ‘Arm’;
1
2
3
4
5
6
7
8

覆盖索引是指select查询语句使用了索引，在返回的列，必须在索引中全部能够找到，如果我们使用id查询，它会直接走聚集索引查询，一次索引扫描，直接返回数据，性能高。

如果按照二级索引查询数据的时候，返回的列中没有创建索引，有可能会触发回表查询，尽量避免使用select *，尽量在返回的列中都包含添加索引的字段

2.11、MYSQL超大分页处理

优化思路: 一般分页查询时，通过创建覆盖索引能够比较好地提高性能，可以通过覆盖索引加子查询形式进行优化

select *
from tb_sku t,(select id from tb_sku order by id limit 9000000,10) a
where t.id = a.id;
1
2
3

2.12、索引创建原则有哪些？

• 针对于数据量较大，且查询比较频繁的表建立索引。
• 针对于常作为查询条件（where）、排序（order by）、分组（group by）操作的字段建立索引。
• 尽量选择区分度高的列作为索引，尽量建立唯一索引，区分度越高，使用索引的效率越高。
• 如果是字符串类型的字段，字段的长度较长，可以针对于字段的特点，建立前缀索引。
• 尽量使用联合索引，减少单列索引，查询时，联合索引很多时候可以覆盖索引，节省存储空间，避免回表，提高查询效率。
• 要控制索引的数量，索引并不是多多益善，索引越多，维护索引结构的代价也就越大，会影响增删改的效率。
• 如果索引列不能存储NULL值，请在创建表时使用NOT NULL约束它。当优化器知道每列是否包含NULL值时，它可以更好地确定哪个索引最有效地用于查询。

2.13、什么情况下索引会失效

• 违反最左前缀法则

  如果索引了多列，要遵守最左前缀法则。指的是查询从索引的最左前列开始，并且不跳过索引中的列。匹配最左前缀法则，走索引。

• 范围查询右边的列，不能使用索引 。

• 不要在索引列上进行运算操作， 索引将失效。

• 字符串不加单引号，造成索引失效（类型转换）。

• 以%开头的Like模糊查询，索引失效。如果仅仅是尾部模糊匹配，索引不会失效。如果是头部模糊匹配，索引失效。

2.14、sql的优化的经验

• 表的设计优化
• 索引优化
• SQL语句优化
• 主从复制、读写分离
• 分库分表

2.14.1、表的设计优化（参考阿里开发手册《嵩山版》）

• 比如设置合适的数值（tinyint int bigint），要根据实际情况选择
• 比如设置合适的字符串类型（char和varchar）char定长效率高，varchar可变长度，效率稍低。

2.14.2、SQL语句优化

• SELECT语句务必指明字段名称（避免直接使用select * ）
• SQL语句要避免造成索引失效的写法
• 尽量用union all代替union union会多一次过滤，效率低
• 避免在where子句中对字段进行表达式操作
• Join优化 能用innerjoin 就不用left join right join，如必须使用 一定要以小表为驱动，内连接会对两个表进行优化，优先把小表放到外边，把大表放到里边。left join 或 right join，不会重新调整顺序

2.14.3、主从复制、读写分离

如果数据库的使用场景读的操作比较多的时候，为了避免写的操作所造成的性能影响 可以采用读写分离的架构。

读写分离解决的是，数据库的写入，影响了查询的效率。

2.15、事务的特性

事务是一组操作的集合，它是一个不可分割的工作单位，事务会把所有的操作作为一个整体一起向系统提交或撤销操作请求，即这些操作要么同时成功，要么同时失败。

• 原子性（Atomicity）：事务是不可分割的最小操作单元，要么全部成功，要么全部失败。
• 一致性（Consistency）：事务完成时，必须使所有的数据都保持一致状态。
• 隔离性（Isolation）：数据库系统提供的隔离机制，保证事务在不受外部并发操作影响的独立环境下运行。
• 持久性（Durability）：事务一旦提交或回滚，它对数据库中的数据的改变就是永久的。

2.16、并发事务带来哪些问题

2.17、怎么解决这些问题呢？MySQL的默认隔离级别是？

注意：事务隔离级别越高，数据越安全，但是性能越低。

• READ UNCOMMITTED 未提交读
  • 脏读、不可重复读、幻读
• READ COMMITTED 读已提交
  • 不可重复读、幻读
• REPEATABLE READ 可重复读
  • 幻读
• SERIALIZABLE 串行化

2.18、undo log和redo log的区别

• 缓冲池（buffer pool）:主内存中的一个区域，里面可以缓存磁盘上经常操作的真实数据，在执行增删改查操作时，先操作缓冲池中的数据（若缓冲池没有数据，则从磁盘加载并缓存），以一定频率刷新到磁盘，从而减少磁盘IO，加快处理速度

• 数据页（page）:是InnoDB 存储引擎磁盘管理的最小单元，每个页的大小默认为 16KB。页中存储的是行数据

2.18.1、redo log

重做日志，记录的是事务提交时数据页的物理修改，是用来实现事务的持久性。

该日志文件由两部分组成：重做日志缓冲（redo log buffer）以及重做日志文件（redo log file）,前者是在内存中，后者在磁盘中。当事务提交之后会把所有修改信息都存到该日志文件中, 用于在刷新脏页到磁盘,发生错误时, 进行数据恢复使用。

2.18.2、undo log

回滚日志，用于记录数据被修改前的信息 , 作用包含两个 : 提供回滚 和 MVCC(多版本并发控制) 。undo log和redo log记录物理日志不一样，它是逻辑日志。

• 可以认为当delete一条记录时，undo log中会记录一条对应的insert记录，反之亦然，

• 当update一条记录时，它记录一条对应相反的update记录。当执行rollback时，就可以从undo log中的逻辑记录读取到相应的内容并进行回滚。

undo log可以实现事务的一致性和原子性

• redo log: 记录的是数据页的物理变化，服务宕机可用来同步数据
• undo log ：记录的是逻辑日志，当事务回滚时，通过逆操作恢复原来的数据
• redo log保证了事务的持久性，undo log保证了事务的原子性和一致性

2.19、事务中的隔离性是如何保证

• 锁：排他锁（如一个事务获取了一个数据行的排他锁，其他事务就不能再获取该行的其他锁）
• mvcc : 多版本并发控制

2.20、MVCC实现原理

全称 Multi-Version Concurrency Control，多版本并发控制。指维护一个数据的多个版本，使得读写操作没有冲突

MVCC的具体实现，主要依赖于数据库记录中的隐式字段、undo log日志、readView。

2.20.1、记录中的隐藏字段

2.20.2、undo log

回滚日志，在insert、update、delete的时候产生的便于数据回滚的日志。

当insert的时候，产生的undo log日志只在回滚时需要，在事务提交后，可被立即删除。

而update、delete的时候，产生的undo log日志不仅在回滚时需要，mvcc版本访问也需要，不会立即被删除。

• undo log版本链

不同事务或相同事务对同一条记录进行修改，会导致该记录的undolog生成一条记录版本链表，链表的头部是最新的旧记录，链表尾部是最早的旧记录。

2.20.3、readview

ReadView（读视图）是 快照读 SQL执行时MVCC提取数据的依据，记录并维护系统当前活跃的事务（未提交的）id。

• 当前读

读取的是记录的最新版本，读取时还要保证其他并发事务不能修改当前记录，会对读取的记录进行加锁。对于我们日常的操作，如：select … lock in share mode(共享锁)，select … for update、update、insert、delete(排他锁)都是一种当前读。

• 快照读

简单的select（不加锁）就是快照读，快照读，读取的是记录数据的可见版本，有可能是历史数据，不加锁，是非阻塞读。

• Read Committed：每次select，都生成一个快照读。
• Repeatable Read：开启事务后第一个select语句才是快照读的地方。

ReadView中包含了四个核心字段

不同的隔离级别，生成ReadView的时机不同：

• READ COMMITTED ：在事务中每一次执行快照读时生成ReadView。
• REPEATABLE READ：仅在事务中第一次执行快照读时生成ReadView，后续复用该ReadView。

2.20.4、参考回答

MySQL中的多版本并发控制。指维护一个数据的多个版本，使得读写操作没有冲突

隐藏字段：

• trx_id(事务id)，记录每一次操作的事务id，是自增的

• roll_pointer(回滚指针)，指向上一个版本的事务版本记录地址

undo log：

• 回滚日志，存储老版本数据

• 版本链：多个事务并行操作某一行记录，记录不同事务修改数据的版本，通过roll_pointer指针形成一个链表

readView解决的是一个事务查询选择版本的问题

• 根据readView的匹配规则和当前的一些事务id判断该访问那个版本的数据

• 不同的隔离级别快照读是不一样的，最终的访问的结果不一样

  • RC ：每一次执行快照读时生成ReadView

  • RR：仅在事务中第一次执行快照读时生成ReadView，后续复用

2.21、MySQL主从同步原理

MySQL主从复制的核心就是二进制日志，二进制日志（BINLOG）记录了所有的 DDL（数据定义语言）语句和 DML（数据操纵语言）语句，但不包括数据查询（SELECT、SHOW）语句。

复制分成三步：

1. Master 主库在事务提交时，会把数据变更记录在二进制日志文件 Binlog 中。
2. 从库读取主库的二进制日志文件 Binlog ，写入到从库的中继日志 Relay Log 。
3. slave重做中继日志中的事件，将改变反映它自己的数据。

2.22、项目用过分库分表吗

分库分表的时机：

1，前提，项目业务数据逐渐增多，或业务发展比较迅速（单表的数据量达1000W或20G以后）

2，优化已解决不了性能问题（主从读写分离、查询索引…）

3，IO瓶颈（磁盘IO、网络IO）、CPU瓶颈（聚合查询、连接数太多）

2.22.1、拆分策略

1，水平分库，将一个库的数据拆分到多个库中，解决海量数据存储和高并发的问题
2，水平分表，解决单表存储和性能的问题
3，垂直分库，根据业务进行拆分，高并发下提高磁盘IO和网络连接数
4，垂直分表，冷热数据分离，多表互不影响

2.22.2、垂直拆分

垂直分库

垂直分库：以表为依据，根据业务将不同表拆分到不同库中。

特点：

1. 按业务对数据分级管理、维护、监控、扩展
2. 在高并发下，提高磁盘IO和数据量连接数

垂直分表

拆分规则：

• 把不常用的字段单独放在一张表
• 把text，blob等大字段拆分出来放在附表中

垂直分表：以字段为依据，根据字段属性将不同字段拆分到不同表中。

特点：

• 冷热数据分离
• 减少IO过渡争抢，两表互不影响

2.22.3、水平拆分

水平分库

水平分库：将一个库的数据拆分到多个库中。

特点：

• 解决了单库大数量，高并发的性能瓶颈问题
• 提高了系统的稳定性和可用性

路由规则

• 根据id节点取模
• 按id也就是范围路由，节点1(1-100万 ),节点2(100万-200万)
• …

水平分表

水平分表：将一个表的数据拆分到多个表中(可以在同一个库内)。

特点：

• 优化单一表数据量过大而产生的性能问题;
• 避免IO争抢并减少锁表的几率;

2.22.4、新的问题和新的技术

分库之后的问题：

• 分布式事务一致性问题
• 跨节点关联查询
• 跨节点分页、排序函数

分库分表中间件：

• sharding-sphere
• mycat

三、框架篇

3.1、Spring框架中的单例bean是线程安全的吗？

• singleton：bean在每个Spring IOC容器中只有一个实例。
• prototype：一个bean的定义可以有多个实例。

不是线程安全的

当多用户同时请求一个服务时，容器会给每一个请求分配一个线程，这是多个线程会并发执行该请求对应的业务逻辑（成员方法），如果该处理逻辑中有对该单列状态的修改（体现为该单例的成员属性），则必须考虑线程同步问题。

Spring框架并没有对单例bean进行任何多线程的封装处理。关于单例bean的线程安全和并发问题需要开发者自行去搞定。

比如：我们通常在项目中使用的Spring bean都是不可可变的状态(比如Service类和DAO类)，所以在某种程度上说Spring的单例bean是线程安全的。

如果你的bean有多种状态的话（比如 View Model对象），就需要自行保证线程安全。最浅显的解决办法就是将多态bean的作用由“singleton”变更为“prototype”。

3.2、什么是AOP

AOP称为面向切面编程，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。

常见的AOP使用场景：

• 记录操作日志
• 缓存处理
• Spring中内置的事务处理

3.3、项目中有没有使用到AOP

记录操作日志，缓存，spring实现的事务

核心是：使用aop中的环绕通知+切点表达式（找到要记录日志的方法），通过环绕通知的参数获取请求方法的参数（类、方法、注解、请求方式等），获取到这些参数以后，保存到数据库

3.4、Spring中的事务是如何实现的

Spring支持编程式事务管理和声明式事务管理两种方式。

• 编程式事务控制：需使用TransactionTemplate来进行实现，对业务代码有侵入性，项目中很少使用
• 声明式事务管理：声明式事务管理建立在AOP之上的。其本质是通过AOP功能，对方法前后进行拦截，将事务处理的功能编织到拦截的方法中，也就是在目标方法开始之前加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

@Around("pointcut()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    try {
        //开启事务
        //执行业务代码
        Object proceed = joinPoint.proceed();
        //提交事务
        return proceed;
    }catch (Exception e){
        e.printStackTrace();
        //回滚事务
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

3.5、Spring中事务失效的场景有哪些

异常捕获处理

原因

• 事务通知只有捉到了目标抛出的异常，才能进行后续的回滚处理，如果目标自己处理掉异常，事务通知无法知悉

解決

• 在catch块添加throw new RuntimeException(e)抛出

抛出检查异常

原因

• Spring 默认只会回滚非检查异常

解決

• 配置rollbackFor属性

  @Transactional(rollbackFor=Exception.class)
  1

非public方法导致的事务失效

原因

• Spring 为方法创建代理、添加事务通知、前提条件都是该方法是 public 的

解決

• 改为 public 方法

3.6、Spring的bean的生命周期

1. 通过BeanDefinition获取bean的定义信息
2. 调用构造函数实例化bean
3. bean的依赖注入
4. 处理Aware接口(BeanNameAware、BeanFactoryAware、ApplicationContextAware)
5. Bean的后置处理器BeanPostProcessor-前置
6. 初始化方法(InitializingBean、init-method)
7. Bean的后置处理器BeanPostProcessor-后置
8. 销毁bean

3.7、Spring中的循环引用

循环依赖：循环依赖其实就是循环引用,也就是两个或两个以上的bean互相持有对方,最终形成闭环。比如A依赖于B,B依赖于A

循环依赖在spring中是允许存在，spring框架依据三级缓存已经解决了大部分的循环依赖

3.8、具体解决流程

1. 先实例A对象，同时会创建ObjectFactory对象存入三级缓存singletonFactories
2. A在初始化的时候需要B对象，这个走B的创建的逻辑
3. B实例化完成，也会创建ObjectFactory对象存入三级缓存singletonFactories
4. B需要注入A，通过三级缓存中获取ObjectFactory来生成一个A的对象同时存入二级缓存，这个是有两种情况，一个是可能是A的普通对象，另外一个是A的代理对象，都可以让ObjectFactory来生产对应的对象，这也是三级缓存的关键
5. B通过从通过二级缓存earlySingletonObjects 获得到A的对象后可以正常注入，B创建成功，存入一级缓存singletonObjects
6. 回到A对象初始化，因为B对象已经创建完成，则可以直接注入B，A创建成功存入一次缓存singletonObjects
7. 二级缓存中的临时对象A清除

3.9、构造方法出现了循环依赖怎么解决

由于bean的生命周期中构造函数是第一个执行的，spring框架并不能解决构造函数的的依赖注入，可以使用@Lazy懒加载，什么时候需要对象再进行bean对象的创建。

public A(@Lazy B b){
    System.out.println("A的构造方法执行了...");
    this.b = b ;
}
1
2
3
4

3.10、SpringMVC的执行流程

3.10.1、视图阶段（JSP）

1、用户发送出请求到前端控制器DispatcherServlet，这是一个调度中心

2、DispatcherServlet收到请求调用HandlerMapping（处理器映射器）。

3、HandlerMapping找到具体的处理器(可查找xml配置或注解配置)，生成处理器对象及处理器拦截器(如果有)，再一起返回给DispatcherServlet。

4、DispatcherServlet调用HandlerAdapter（处理器适配器）。

5、HandlerAdapter经过适配调用具体的处理器（Handler/Controller）。

6、Controller执行完成返回ModelAndView对象。

7、HandlerAdapter将Controller执行结果ModelAndView返回给DispatcherServlet。

8、DispatcherServlet将ModelAndView传给ViewReslover（视图解析器）。

9、ViewReslover解析后返回具体View（视图）。

10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。

11、DispatcherServlet响应用户。

3.10.2、前后端分离阶段（接口开发，异步请求）

1、用户发送出请求到前端控制器DispatcherServlet

2、DispatcherServlet收到请求调用HandlerMapping（处理器映射器）

3、HandlerMapping找到具体的处理器，生成处理器对象及处理器拦截器(如果有)，再一起返回给DispatcherServlet。

4、DispatcherServlet调用HandlerAdapter（处理器适配器）

5、HandlerAdapter经过适配调用具体的处理器（Handler/Controller）

6、方法上添加了@ResponseBody

7、通过HttpMessageConverter来返回结果转换为JSON并响应

3.11、Springboot自动配置原理

1、在Spring Boot项目中的引导类上有一个注解@SpringBootApplication，这个注解是对三个注解进行了封装，分别是：

• @SpringBootConfiguration
• @EnableAutoConfiguration
• @ComponentScan

2、其中@EnableAutoConfiguration是实现自动化配置的核心注解。 该注解通过@Import注解导入对应的配置选择器。

内部就是读取了该项目和该项目引用的Jar包的的classpath路径下META-INF/spring.factories文件中的所配置的类的全类名。

在这些配置类中所定义的Bean会根据条件注解所指定的条件来决定是否需要将其导入到Spring容器中。

3、一般条件判断会有像@ConditionalOnClass这样的注解，判断是否有对应的class文件，如果有则加载该类，把这个配置类的所有的Bean放入spring容器中使用。

3.12、Spring 的常见注解

3.13、SpringMVC常见注解

3.14、Springboot常见注解

Spring Boot的核心注解是@SpringBootApplication , 他由几个注解组成 :

3.15、MyBatis执行流程

1. 读取MyBatis配置文件：mybatis-config.xml加载运行环境和映射文件
2. 构造会话工厂SqlSessionFactory
3. 会话工厂创建SqlSession对象（包含了执行SQL语句的所有方法）
4. 操作数据库的接口，Executor执行器，同时负责查询缓存的维护
5. Executor接口的执行方法中有一个MappedStatement类型的参数，封装了映射信息
6. 输入参数映射
7. 输出结果映射

3.16、Mybatis是否支持延迟加载？

支持

延迟加载的意思是：就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。

Mybatis支持一对一关联对象和一对多关联集合对象的延迟加载

在Mybatis配置文件中，可以配置是否启用延迟加载lazyLoadingEnabled=true|false，默认是关闭的

3.17、延迟加载的底层原理

1. 使用CGLIB创建目标对象的代理对象
2. 当调用目标方法时，进入拦截器invoke方法，发现目标方法是null值，执行sql查询
3. 获取数据以后，调用set方法设置属性值，再继续查询目标方法，就有值了

3.18、Mybatis的一级、二级缓存

mybatis的一级缓存: 基于 PerpetualCache 的 HashMap 本地缓存，其存储作用域为 Session，当Session进行flush或close之后，该Session中的所有Cache就将清空，默认打开一级缓存

关于二级缓存需要单独开启

二级缓存是基于namespace和mapper的作用域起作用的，不是依赖于SQL session，默认也是采用 PerpetualCache，HashMap 存储。

如果想要开启二级缓存需要在全局配置文件和映射文件中开启配置才行。

开启方式，两步：

1，全局配置文件

<settings>
	<setting name="cacheEnabled" value="true
</settings>
1
2
3

2、映射文件
使用<cache/>标签让当前mapper生效二级缓存

注意事项

1，对于缓存数据更新机制，当某一个作用域(一级缓存 Session/二级缓存Namespaces)的进行了新增、修改、删除操作后，默认该作用域下所有 select 中的缓存将被 clear

2，二级缓存需要缓存的数据实现Serializable接口

3，只有会话提交或者关闭以后，一级缓存中的数据才会转移到二级缓存中

3.19、Mybatis的二级缓存什么时候会清理缓存中的数据

当某一个作用域(一级缓存 Session/二级缓存Namespaces)的进行了新增、修改、删除操作后，默认该作用域下所有 select 中的缓存将被 clear。

四、微服务

4.1、Spring Cloud 5大组件

早期我们一般认为的Spring Cloud五大组件是

• Eureka : 注册中心
• Ribbon : 负载均衡
• Feign : 远程调用
• Hystrix : 服务熔断
• Zuul/Gateway : 网关

随着SpringCloudAlibba在国内兴起 , 我们项目中使用了一些阿里巴巴的组件

• 注册中心/配置中心 Nacos
• 负载均衡 Ribbon
• 服务调用 Feign
• 服务保护 sentinel
• 服务网关 Gateway

4.2、服务注册和发现是什么意思？Spring Cloud 如何实现服务注册发现？

主要三块大功能，分别是服务注册 、服务发现、服务状态监控

我们当时项目采用的eureka作为注册中心，这个也是spring cloud体系中的一个核心组件

服务注册：服务提供者需要把自己的信息注册到eureka，由eureka来保存这些信息，比如服务名称、ip、端口等等

服务发现：消费者向eureka拉取服务列表信息，如果服务提供者有集群，则消费者会利用负载均衡算法，选择一个发起调用

服务监控：服务提供者会每隔30秒向eureka发送心跳，报告健康状态，如果eureka服务90秒没接收到心跳，从eureka中剔除

4.3、nacos与eureka的区别

Nacos与eureka的共同点（注册中心）

1. 都支持服务注册和服务拉取
2. 都支持服务提供者心跳方式做健康检测

Nacos与Eureka的区别（注册中心）

1. Nacos支持服务端主动检测提供者状态：临时实例采用心跳模式，非临时实例采用主动检测模式
2. 临时实例心跳不正常会被剔除，非临时实例则不会被剔除
3. Nacos支持服务列表变更的消息推送模式，服务列表更新更及时
4. Nacos集群默认采用AP方式，当集群中存在非临时实例时，采用CP模式；Eureka采用AP方式

Nacos还支持了配置中心，eureka则只有注册中心，也是选择使用nacos的一个重要原因

4.4、项目负载均衡如何实现

在服务调用过程中的负载均衡一般使用SpringCloud的Ribbon 组件实现 , Feign的底层已经自动集成了Ribbon , 使用起来非常简单

当发起远程调用时，ribbon先从注册中心拉取服务地址列表，然后按照一定的路由策略选择一个发起远程调用，一般的调用策略是轮询

4.5、Ribbon负载均衡策略

• RoundRobinRule：简单轮询服务列表来选择服务器
• WeightedResponseTimeRule：按照权重来选择服务器，响应时间越长，权重越小
• RandomRule：随机选择一个可用的服务器
• BestAvailableRule：忽略那些短路的服务器，并选择并发数较低的服务器
• RetryRule：重试机制的选择逻辑
• AvailabilityFilteringRule：可用性敏感策略，先过滤非健康的，再选择连接数较小的实例
• ZoneAvoidanceRule：以区域可用的服务器为基础进行服务器的选择。使用Zone对服务器进行分类，这个Zone可以理解为一个机房、一个机架等。而后再对Zone内的多个服务做轮询

4.6、自定义负载均衡策略如何实现

提供了两种方式：

1，创建类实现IRule接口，可以指定负载均衡策略（全局）
2，在客户端的配置文件中，可以配置某一个服务调用的负载均衡策略（局部）

4.7、什么是服务雪崩，怎么解决这个问题？

服务雪崩是指一个服务失败，导致整条链路的服务都失败的情形，一般我们在项目解决的话就是两种方案：

第一个是服务降级，第二个是服务熔断，如果流量太大的话，可以考虑限流。

4.7.1、服务降级

服务自我保护的一种方式，或者保护下游服务的一种方式，用于确保服务不会受请求突增影响变得不可用，确保服务不会崩溃，一般在实际开发中与feign接口整合，编写降级逻辑

4.7.2、服务熔断

默认关闭，如果需要开启需要在引导类上添加注解@EnableCircuitBreaker如果检测到 10 秒内请求的失败率超过 50%，就触发熔断机制。之后每隔 5 秒重新尝试请求微服务，如果微服务不能响应，继续走熔断机制。如果微服务可达，则关闭熔断机制，恢复正常请求。

4.8、微服务是怎么监控的

• Springboot-admin
• prometheus+Grafana
• zipkin
• skywalking

项目中采用的skywalking进行监控的

1，skywalking主要可以监控接口、服务、物理实例的一些状态。特别是在压测的时候可以看到众多服务中哪些服务和接口比较慢，我们可以针对性的分析和优化。

2，我们还在skywalking设置了告警规则，特别是在项目上线以后，如果报错，我们分别设置了可以给相关负责人发短信和发邮件，第一时间知道项目的bug情况，第一时间修复

4.9、项目中如何限流

为什么要限流？

1，并发的确大（突发流量）

2，防止用户恶意刷接口

限流的实现方式：

• Tomcat：可以设置最大连接数
• Nginx，漏桶算法
• 网关，令牌桶算法
• 自定义拦截器

4.9.1、Nginx限流

控制速率（突发流量）

limit_req_zone key zone rate
1

• key:定义限流对象，binary_remote_addr就是一种key，基于客户端ip限流
• Zone：定义共享存储区来存储访问信息，10m可以存储16wip地址访问信息
• Rate：最大访问速率，rate=10r/s 表示每秒最多请求10个请求
• burst=20：相当于桶的大小
• Nodelay：快速处理

控制并发连接数

• limit_conn perip 20：对应的key是 $binary_remote_addr，表示限制单个IP同时最多能持有20个连接。
• limit_conn perserver 100：对应的key是 $server_name，表示虚拟主机(server) 同时能处理并发连接的总数。

4.9.2、网关限流

yml配置文件中，微服务路由设置添加局部过滤器RequestRateLimiter

• key-resolver ：定义限流对象（ ip 、路径、参数），需代码实现，使用spel表达式获取
• replenishRate ：令牌桶每秒填充平均速率。
• urstCapacity ：令牌桶总容量。

4.9.3、回答

1、先来介绍业务，什么情况下去做限流，需要说明QPS具体多少

• 我们当时有一个活动，到了假期就会抢购优惠券，QPS最高可以达到2000，平时10-50之间，为了应对突发流量，需要做限流

• 常规限流，为了防止恶意攻击，保护系统正常运行，我们当时系统能够承受最大的QPS是多少（压测结果）

2、nginx限流

• 控制速率（突发流量），使用的漏桶算法来实现过滤，让请求以固定的速率处理请求，可以应对突发流量
• 控制并发数，限制单个ip的链接数和并发链接的总数

3、网关限流

• 在spring cloud gateway中支持局部过滤器RequestRateLimiter来做限流，使用的是令牌桶算法
• 可以根据ip或路径进行限流，可以设置每秒填充平均速率，和令牌桶总容量

4.10、限流常见的算法有哪些呢？

比较常见的限流算法有漏桶算法和令牌桶算法

漏桶算法是把请求存入到桶中，以固定速率从桶中流出，可以让我们的服务做到绝对的平均，起到很好的限流效果

令牌桶算法在桶中存储的是令牌，按照一定的速率生成令牌，每个请求都要先申请令牌，申请到令牌以后才能正常请求，也可以起到很好的限流作用

它们的区别是，漏桶和令牌桶都可以处理突发流量，其中漏桶可以做到绝对的平滑，令牌桶有可能会产生突发大量请求的情况，一般nginx限流采用的漏桶，spring cloud gateway中可以支持令牌桶算法

4.11、什么是CAP理论

CAP主要是在分布式项目下的一个理论。包含了三项，一致性、可用性、分区容错性

• 一致性(Consistency)是指更新操作成功并返回客户端完成后，所有节点在同一时间的数据完全一致(强一致性)，不能存在中间状态。
• 可用性(Availability) 是指系统提供的服务必须一直处于可用的状态，对于用户的每一个操作请求总是能够在有限的时间内返回结果。
• 分区容错性(Partition tolerance) 是指分布式系统在遇到任何网络分区故障时，仍然需要能够保证对外提供满足一致性和可用性的服务，除非是整个网络环境都发生了故障。

结论

• 分布式系统节点之间肯定是需要网络连接的，分区（P）是必然存在的
• 如果保证访问的高可用性（A）,可以持续对外提供服务，但不能保证数据的强一致性–> AP
• 如果保证访问的数据强一致性（C）,就要放弃高可用性 --> CP

4.12、为什么分布式系统中无法同时保证一致性和可用性

首先一个前提，对于分布式系统而言，分区容错性是一个最基本的要求，因此基本上我们在设计分布式系统的时候只能从一致性（C）和可用性（A）之间进行取舍。

如果保证了一致性（C）：对于节点N1和N2，当往N1里写数据时，N2上的操作必须被暂停，只有当N1同步数据到N2时才能对N2进行读写请求，在N2被暂停操作期间客户端提交的请求会收到失败或超时。显然，这与可用性是相悖的。

如果保证了可用性（A）：那就不能暂停N2的读写操作，但同时N1在写数据的话，这就违背了一致性的要求。

4.13、什么是BASE理论

BASE是CAP理论中AP方案的延伸，核心思想是即使无法做到强一致性（StrongConsistency，CAP的一致性就是强一致性），但应用可以采用适合的方式达到最终一致性（Eventual Consitency）。它的思想包含三方面：

• Basically Available （基本可用）：分布式系统在出现故障时，允许损失部分可用性，即保证核心可用。
• Soft State（软状态）：在一定时间内，允许出现中间状态，比如临时的不一致状态。
• Eventually Consistent（最终一致性）：虽然无法保证强一致性，但是在软状态结束后，最终达到数据一致。

4.14、你们采用哪种分布式事务解决方案

4.14.1、Seata事务管理中有三个重要的角色：

• TC (Transaction Coordinator) - **事务协调者：**维护全局和分支事务的状态，协调全局事务提交或回滚。
• TM (Transaction Manager) - **事务管理器：**定义全局事务的范围、开始全局事务、提交或回滚全局事务。
• RM (Resource Manager) - **资源管理器：**管理分支事务处理的资源，与TC交谈以注册分支事务和报告分支事务的状态，并驱动分支事务提交或回滚。

4.14.2、seata的XA模式

RM一阶段的工作：

• 注册分支事务到TC
• 执行分支业务sql但不提交
• 报告执行状态到TC

TC二阶段的工作：

• TC检测各分支事务执行状态
  • 如果都成功，通知所有RM提交事务
  • 如果有失败，通知所有RM回滚事务

RM二阶段的工作：

• 接收TC指令，提交或回滚事务

4.14.3、AT模式原理

AT模式同样是分阶段提交的事务模型，不过缺弥补了XA模型中资源锁定周期过长的缺陷。

阶段一RM的工作：

• 注册分支事务

• 记录undo-log（数据快照）

• 执行业务sql并提交

• 报告事务状态

阶段二提交时RM的工作：

• 删除undo-log即可

阶段二回滚时RM的工作：

• 根据undo-log恢复数据到更新前

4.14.4、TCC模式原理

1、Try：资源的检测和预留；

2、Confirm：完成资源操作业务；要求 Try 成功 Confirm 一定要能成功。

3、Cancel：预留资源释放，可以理解为try的反向操作。

4.14.5、MQ分布式事务

4.14.6、描述项目中采用的哪种方案（seata | MQ）

1、seata的XA模式，CP，需要互相等待各个分支事务提交，可以保证强一致性，性能差

2、seata的AT模式，AP，底层使用undo log 实现，性能好

3、seata的TCC模式，AP，性能较好，不过需要人工编码实现

4、MQ模式实现分布式事务，在A服务写数据的时候，需要在同一个事务内发送消息到另外一个事务，异步，性能最好

1、3适合银行业务

2、4适合互联网业务

4.15、分布式服务的接口幂等性如何设计

• 幂等: 多次调用方法或者接口不会改变业务状态，可以保证重复调用的结果和单次调用的结果一致
• 如果是新增数据，可以使用数据库的唯一索引
• 如果是新增或修改数据
  • 分布式锁，性能较低
  • 使用token+redis来实现，性能较好
    • 第一次请求，生成一个唯一token存入redis，返回给前端
    • 第二次请求，业务处理，携带之前的token，到redis进行验证，如果存在，可以执行业务，删除token；如果不存在，则直接返回，不处理业务

4.16、你们项目中使用了什么分布式任务调度

4.16.1、xxl-job解决的问题

• 解决集群任务的重复执行问题
• cron表达式定义灵活
• 定时任务失败了，重试和统计
• 任务量大，分片执行

4.16.2、xxl-job路由策略有哪些？

xxl-job提供了很多的路由策略，我们平时用的较多就是：轮询、故障转移、分片广播…

1. FIRST（第一个）：固定选择第一个机器；

2. LAST（最后一个）：固定选择最后一个机器；

3. ROUND（轮询）

4. RANDOM（随机）：随机选择在线的机器；

5. CONSISTENT_HASH（一致性HASH）：每个任务按照Hash算法固定选择某一台机器，且所有任务均匀散列在不同机器上。

6. LEAST_FREQUENTLY_USED（最不经常使用）：使用频率最低的机器优先被选举；

7. LEAST_RECENTLY_USED（最近最久未使用）：最久未使用的机器优先被选举；

8. FAILOVER（故障转移）：按照顺序依次进行心跳检测，第一个心跳检测成功的机器选定为目标执行器并发起调度；

9. BUSYOVER（忙碌转移）：按照顺序依次进行空闲检测，第一个空闲检测成功的机器选定为目标执行器并发起调度；

10. SHARDING_BROADCAST(分片广播)：广播触发对应集群中所有机器执行一次任务，同时系统自动传递分片参数；可根据分片参数开发分片任务；

4.16.3、xxl-job任务执行失败怎么解决？

1. 路由策略选择故障转移，优先使用健康的实例来执行任务

2. 如果还有失败的，我们在创建任务时，可以设置重试次数

3. 如果还有失败的，就可以查看日志或者配置邮件告警来通知相关负责人解决

4.16.4、如果有大数据量的任务同时都需要执行，怎么解决？

我们会让部署多个实例，共同去执行这些批量的任务，其中任务的路由策略是分片广播

1. BUSYOVER（忙碌转移）：按照顺序依次进行空闲检测，第一个空闲检测成功的机器选定为目标执行器并发起调度；

2. SHARDING_BROADCAST(分片广播)：广播触发对应集群中所有机器执行一次任务，同时系统自动传递分片参数；可根据分片参数开发分片任务；

五、消息中间件

5.1、RabbitMQ如何保证消息不丢失

5.1.1、生产者确认机制

RabbitMQ提供了publisher confirm机制来避免消息发送到MQ过程中丢失。消息发送到MQ以后，会返回一个结果给发送者，表示消息是否处理成功

消息失败之后如何处理呢？

• 回调方法即时重发
• 记录日志
• 保存到数据库然后定时重发，成功发送后即刻删除表中的数据

5.1.2、消息持久化

MQ默认是内存存储消息，开启持久化功能可以确保缓存在MQ中的消息不丢失。

• 交换机持久化

  @Bean
  public DirectExchange simpleExchange(){
      // 三个参数：交换机名称、是否持久化、当没有queue与其绑定时是否自动删除 
      return new DirectExchange("simple.direct", true, false);
  }
  1
  2
  3
  4
  5

• 队列持久化

  @Bean
  public Queue simpleQueue(){
      // 使用QueueBuilder构建队列，durable就是持久化的
      return QueueBuilder.durable("simple.queue").build();
  }
  1
  2
  3
  4
  5

• 消息持久化，SpringAMQP中的的消息默认是持久的，可以通过MessageProperties中的DeliveryMode来指定

  Message msg = MessageBuilder
          .withBody(message.getBytes(StandardCharsets.UTF_8)) // 消息体 
          .setDeliveryMode(MessageDeliveryMode.PERSISTENT) // 持久化     
          .build();
  1
  2
  3
  4

5.1.3、消费者确认

RabbitMQ支持消费者确认机制，即：消费者处理消息后可以向MQ发送ack回执，MQ收到ack回执后才会删除该消息。而SpringAMQP则允许配置三种确认模式：

• manual：手动ack，需要在业务代码结束后，调用api发送ack。
• auto：自动ack，由spring监测listener代码是否出现异常，没有异常则返回ack；抛出异常则返回nack
• none：关闭ack，MQ假定消费者获取消息后会成功处理，因此消息投递后立即被删除

我们可以利用Spring的retry机制，在消费者出现异常时利用本地重试，设置重试次数，当次数达到了以后，如果消息依然失败，将消息投递到异常交换机，交由人工处理

5.2、RabbitMQ消息重复消费

消费者是设置了自动确认机制，当服务还没来得及给MQ确认的时候，服务宕机了，导致服务重启之后，又消费了一次消息。这样就重复消费了

解决方案

• 每条消息设置一个唯一的标识id
• 幂等方案：分布式锁、数据库锁（悲观锁、乐观锁）

5.3、RabbitMQ中死信交换机 （延迟队列）

延迟队列就是用到了死信交换机 + TTL（消息存活时间）实现的。

• 延迟队列：进入队列的消息会被延迟消费的队列
• 场景：超时订单、限时优惠、定时发布

如果消息超时未消费就会变成死信，在RabbitMQ中如果消息成为死信，队列可以绑定一个死信交换机，在死信交换机上可以绑定其他队列，在我们发消息的时候可以按照需求指定TTL的时间，这样就实现了延迟队列的功能了。

我记得RabbitMQ还有一种方式可以实现延迟队列，在RabbitMQ中安装一个死信插件，这样更方便一些，我们只需要在声明交互机的时候，指定这个就是死信交换机，然后在发送消息的时候直接指定超时时间就行了，相对于死信交换机+TTL要省略了一些步骤

5.4、100万消息堆积在MQ , 如何解决

解决消息堆积有三种种思路：

• 提高消费者的消费能力 ,可以使用多线程消费任务
• 增加更多消费者，提高消费速度
  • 使用工作队列模式, 设置多个消费者消费消费同一个队列中的消息
• 扩大队列容积，提高堆积上限
  • 可以使用RabbitMQ惰性队列，惰性队列的好处主要是
    • 接收到消息后直接存入磁盘而非内存
    • 消费者要消费消息时才会从磁盘中读取并加载到内存
    • 支持数百万条的消息存储

5.5、RabbitMQ的高可用机制

5.5.1、普通集群

普通集群，或者叫标准集群（classic cluster），具备下列特征：

• 会在集群的各个节点间共享部分数据，包括：交换机、队列元信息。不包含队列中的消息。
• 当访问集群某节点时，如果队列不在该节点，会从数据所在节点传递到当前节点并返回
• 队列所在节点宕机，队列中的消息就会丢失

5.5.2、镜像集群

镜像集群：本质是主从模式，具备下面的特征：

• 交换机、队列、队列中的消息会在各个mq的镜像节点之间同步备份。
• 创建队列的节点被称为该队列的主节点，备份到的其它节点叫做该队列的镜像节点。
• 一个队列的主节点可能是另一个队列的镜像节点
• 所有操作都是主节点完成，然后同步给镜像节点
• 主节点宕机后，镜像节点会替代成新的主节点

5.5.3、仲裁队列

仲裁队列：仲裁队列是3.8版本以后才有的新功能，用来替代镜像队列，具备下列特征：

• 与镜像队列一样，都是主从模式，支持主从数据同步
• 使用非常简单，没有复杂的配置
• 主从同步基于Raft协议，强一致

@Bean
public Queue quorumQueue() {
    return QueueBuilder
            .durable("quorum.queue") // 持久化             
            .quorum() // 仲裁队列            
            .build();
}
1
2
3
4
5
6
7

5.6、Kafka是如何保证消息不丢失

使用Kafka在消息的收发过程都会出现消息丢失 , Kafka分别给出了解决方案

• 生产者发送消息到Brocker丢失
• 消息在Brocker中存储丢失
• 消费者从Brocker接收消息丢失

5.6.1、生产者发送消息到Brocker丢失

• 设置异步发送，发送失败使用回调进行记录或重发。
• 失败重试，参数配置，可以设置重试次数。

5.6.2、消息在Brocker中存储丢失

发送确认机制acks

选择all，让所有的副本都参与保存数据后确认。

5.6.3、消费者从Brocker接收消息丢失

• 关闭自动提交偏移量，开启手动提交偏移量
• 提交方式，最好是同步+异步提交

5.7、Kafka中消息的重复消费

• 关闭自动提交偏移量，开启手动提交偏移量
• 提交方式，最好是同步+异步提交
• 幂等方案

5.8、Kafka是如何保证消费的顺序性

问题原因：

一个topic的数据可能存储在不同的分区中，每个分区都有一个按照顺序的存储的偏移量，如果消费者关联了多个分区不能保证顺序性。

解决方案：

• 发送消息时指定分区号
• 发送消息时按照相同的业务设置相同的key

因为默认情况下分区也是通过key的hashcode值来选择分区的，hash值如果一样的话，分区肯定也是一样的

5.9、Kafka的高可用机制

5.9.1、集群模式

kafka集群指的是由多个broker实例组成，即使某一台宕机，也不耽误其他broker继续对外提供服务

5.9.2、分区备份机制

• 一个topic有多个分区，每个分区有多个副本，其中有一个leader，其余的是follower，副本存储在不同的broker中
• 所有的分区副本的内容是都是相同的，如果leader发生故障时，会自动将其中一个follower提升为leader

5.10、解释一下复制机制中的ISR

ISR的意思是in-sync replica，就是需要同步复制保存的follower

其中分区副本有很多的follower，分为了两类

• ISR，与leader副本同步保存数据，
• 普通的副本，是异步同步数据

如果leader失效后，需要选出新的leader，选举的原则如下：

• 选举时优先从ISR中选定，因为这个列表中follower的数据是与leader同步的
• 如果ISR列表中的follower都不行了，就只能从其他follower中选取

5.11、Kafka数据清理机制

Kafka存储结构

• Kafka中topic的数据存储在分区上，分区如果文件过大会分段存储segment
• 每个分段都在磁盘上以索引(xxxx.index)和日志文件(xxxx.log)的形式存储，
• 分段的好处是，第一能够减少单个文件内容的大小，查找数据方便，第二方便kafka进行日志清理。

在kafka中提供了两个日志的清理策略

• 第一，根据消息的保留时间，当消息保存的时间超过了指定的时间，就会触发清理，默认是168小时（ 7天）
• 第二是根据topic存储的数据大小，当topic所占的日志文件大小大于一定的阈值，则开始删除最久的消息。这个默认是关闭的

这两个策略都可以通过kafka的broker中的配置文件进行设置

5.12、Kafka中实现高性能的设计

kafka 高性能，是多方面协同的结果，包括宏观架构、分布式存储、ISR 数据同步、以及高效的利用磁盘、操作系统特性等。主要体现有这么几点：

• 消息分区： 不受单台服务器的限制，可以不受限的处理更多的数据
• 顺序读写： 磁盘顺序读写，提升读写效率
• 页缓存： 把磁盘中的数据缓存到内存中，把对磁盘的访问变为对内存的访问
• 零拷贝： 减少上下文切换及数据拷贝
• 消息压缩：减少磁盘IO和网络IO
• 分批发送：将消息打包批量发送，减少网络开销

六、Java集合

6.1、List相关面试题

数组（Array）是一种用连续的内存空间存储相同数据类型数据的线性数据结构。

数组下标为什么从0开始

• 寻址公式是：baseAddress + i * dataTypeSize，计算下标的内存地址效率较高

查找的时间复杂度

• 随机(通过下标)查询的时间复杂度是O(1)
• 查找元素（未知下标）的时间复杂度是O(n)
• 查找元素（未知下标但排序）通过二分查找的时间复杂度是O(logn)

插入和删除时间复杂度

• 插入和删除的时候，为了保证数组的内存连续性，需要挪动数组元素，平均时间复杂度为O(n)

6.2、ArrayList底层的实现原理

底层数据结构

• ArrayList底层是用动态的数组实现的

初始容量

• ArrayList初始容量为0，当第一次添加数据的时候才会初始化容量为10

扩容逻辑

• ArrayList在进行扩容的时候是原来容量的1.5倍，每次扩容都需要拷贝数组

添加逻辑

• 确保数组已使用长度（size）加1之后足够存下下一个数据
• 计算数组的容量，如果当前数组已使用长度+1后的大于当前的数组长度，则调用grow方法扩容（原来的1.5倍）
• 确保新增的数据有地方存储之后，则将新元素添加到位于size的位置上。
• 返回添加成功布尔值。

6.3、ArrayList list = new ArrayList(10)中的list扩容几次

该语句只是声明和实例了一个 ArrayList，指定了容量为 10，未扩容

6.4、实现数组和List之间的转换

• 数组转List ，使用JDK中java.util.Arrays工具类的asList方法
• List转数组，使用List的toArray方法。无参toArray方法返回 Object数组，传入初始化长度的数组对象，返回该对象数组

用Arrays.asList转List后，如果修改了数组内容，list受影响吗

• Arrays.asList转换list之后，如果修改了数组的内容，list会受影响，因为它的底层使用的Arrays类中的一个内部类ArrayList来构造的集合，在这个集合的构造器中，把我们传入的这个集合进行了包装而已，最终指向的都是同一个内存地址

List用toArray转数组后，如果修改了List内容，数组受影响吗

• list用了toArray转数组后，如果修改了list内容，数组不会影响，当调用了toArray以后，在底层是它是进行了数组的拷贝，跟原来的元素就没啥关系了，所以即使list修改了以后，数组也不受影响

6.5、单向链表

链表中的每一个元素称之为结点（Node）

物理存储单元上，非连续、非顺序的存储结构

单向链表：每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。记录下个结点地址的指针叫作后继指针 next

单向链表时间复杂度分析

查询操作

• 只有在查询头节点的时候不需要遍历链表，时间复杂度是O(1)
• 查询其他结点需要遍历链表，时间复杂度是O(n)

插入\删除操作

• 只有在添加和删除头节点的时候不需要遍历链表，时间复杂度是O(1)
• 添加或删除其他结点需要遍历链表找到对应节点后，才能完成新增或删除节点，时间复杂度是O(n)

6.6、双向链表

• 每个结点不止有一个后继指针 next 指向后面的结点
• 有一个前驱指针 prev 指向前面的结点

对比单链表

• 双向链表需要额外的两个空间来存储后继结点和前驱结点的地址
• 支持双向遍历，这样也带来了双向链表操作的灵活性

双向链表时间复杂度分析

查询操作

• 查询头尾结点的时间复杂度是O(1)
• 平均的查询时间复杂度是O(n)
• 给定节点找前驱节点的时间复杂度为O(1)

增删操作

• 头尾结点增删的时间复杂度为O(1)
• 其他部分结点增删的时间复杂度是 O(n)
• 给定节点增删的时间复杂度为O(1)

6.7、ArrayList 和 LinkedList 的区别

1、底层数据结构

• ArrayList 是动态数组的数据结构实现
• LinkedList 是双向链表的数据结构实现

2、操作数据效率

• ArrayList按照下标查询的时间复杂度O(1)【内存是连续的，根据寻址公式】， LinkedList不支持下标查询
• 查找（未知索引）： ArrayList需要遍历，链表也需要链表，时间复杂度都是O(n)
• 新增和删除
  • ArrayList尾部插入和删除，时间复杂度是O(1)；其他部分增删需要挪动数组，时间复杂度是O(n)
  • LinkedList头尾节点增删时间复杂度是O(1)，其他都需要遍历链表，时间复杂度是O(n)

3、内存空间占用

• ArrayList底层是数组，内存连续，节省内存
• LinkedList 是双向链表需要存储数据，和两个指针，更占用内存

4、线程安全

• ArrayList和LinkedList都不是线程安全的
• 如果需要保证线程安全，有两种方案：
  • 在方法内使用，局部变量则是线程安全的
  • 使用线程安全的ArrayList和LinkedList

List<Object> syncArrayList = Collections.synchronizedList(new ArrayList<>());
List<Object> syncLinkedList = Collections.synchronizedList(new LinkedList<>());
1
2

6.8、HashMap

参考地址：https://blog.csdn.net/qq_37242720/article/details/123619848