别的啊复盘

2.properties只支持java  yml支持多重语言，方便扩展

springboot读取配置文件的方式

1.@value 读取

2.@configurationproperties 注入到实体类  直接使用注入ioc容器的实体类

@ConfigurationProperties(prefix="spring.user")

list的三种遍历方式

1.for循环

2.iterator

3.foreach遍历【这种遍历过程中不能删除元素】 

mybatis的三种分页方式

1.使用limit在xml分页

2.使用boundrows 分页，具体就是查询一次 然后在缓存查询

3.通过intereptor拦截器分页，拦截需要分页的sql，然后去拼接sql语句

mysql为什么使用b+树不用调表【io层面 和 插入的效率方面】

1.b+树是多叉平衡术，每个节点16kb，可以存更多的信息，存储2千万数据只需要3层，也只需要3次io， 而调表是一个数据一个节点，他存储2千万要更多的io次数

redis为什么使用调表不用b+树？

redis纯内存操作，所以上边说的层高不再是调表的劣势，

针对插入操作，调表直接插入，而b+树等需要合并拆分，旋转操作，效率低

一个对象多大内存：

对象头： marword 【8字节】+ 类型指针【4字节】

如果boolean是单独使用：boolean占4个字节。

如果boolean是以“boolean数组”的形式使用：boolean占1个字节。

没有实例变量的话就是16个字节

实例变量 

填充字节

• SELECT .. WHERE a = ? AND b = ? ORDER BY c 如何创建索引
• SELECT .. WHERE a = ? AND b > ? ORDER BY c 联合索引abc是否失效

key a b c(a,b,c)

order by能使用索引最左前缀
- order by a
- order by a,b
- order by a,b,c
- order by a DESC,b DESC,c DESC

如果where使用了索引的最左前缀定义为常量  则order by能使用索引
- WHERE a=const order by b,c
- WHERE a=const AND b=const ORDRE BY c
- WHERE a=const AND b>const ORDER BY b,c

不能使用索引进行排序
- ORDERE BY a ASC,b DESC,c DESC   排序不一致
- WHERE g=const ORDER BY b,c   丢失a索引
- WHERE a=const ORDER BY C  丢失b索引
- WHERE a=const ORDER BY d  d不是索引的一部分

mybatis的动态sql标签：

1.if标签  和 where标签一同使用

<select id="findUser" resultType="User">
  SELECT * FROM user
    <where>
        <if test="class != null">
             AND class = #{class}
        </if>
        <if test="phone != null and adress != null">
            AND age > #{age}
        </if>
  </where>
</select>
————————————————
版权声明：本文为CSDN博主「高并发」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：

<select id="findUser" resultType="user">

        select * from user

where class ='12'

<if test ="age !=null">

and age>#{age}

</if>

</select>

2.foreach 标签   集合查询

<select id="findUser" resultType="User">

select * from user

where class in

<foreach item="item" index="index" collection="list" open="(" separator="," close=")">

#{item}

</foreach>

负载均衡算法：

1.轮训

2.加权轮训

3.随机

4.最小连接【记录次数 那个最少转发到那个】

5.ip 的 hash【】

6.一致性hash【分布式缓存 根据hash环进行存储】 

ping的流程

1.首先生成icmp请求报文，将报文和ping的ip地址发送给ip层，进行ip的封装，然后判断是否在同一子网（根据要请求的ip地址和自己是否在同个子网），在同子网在ip层进行arp解析，找到对应的mac地址，封装成mac帧，传递给物理层，传输到对应的接收端 然后另一边解析出icmp报文，反向发送个icmp相应报文。

2.nacos的配置中心的原理，

nacos采用长轮训【客户端发送一次轮训请求到服务器后，当服务端的配置没有变化的时候，这个连接会一直打开，直到有配置的变化或者是超时才会返回】的方式进行查询配置信息向服务端，

客户端每次发送3000个key加上具体信息的md5加密值作为一个字符串发送给服务端，服务端依次判断是否发生了改变，将发生改变的key告诉客户端，然后客户端根据变化的重新查询服务端配置完成具体的配置。

一张自增表里面总共有 7 条数据，删除了最后 2 条数据，重启 MySQL 数据库，又插入了一条数据，此时 id 是几

innodb是6，

myisam是8

因为InnoDB表只把自增主键的最大ID记录到内存中，所以重启数据库或者对表OPTIMIZE操作，都会使最大ID丢失。

但是，如果我们使用表的类型是MylSAM，那么这条记录的ID就是8。因为MylSAM表会把自增主键的最大ID记录到数据文件里面，重启MYSQL后，自增主键的最大ID也不会丢失。

volatile在i++情况会失效：：：：：：：：：：：：：：：：：：：：：

不是线程安全的  只能保证可见性和有序性  不能保证原子性

LRU（最近最久未使用）和LFU（最近最少使用）
幂等性问题接口
调表 
IO多路复用
奇安信
网易1
网易2021提前

Redis-从海量数据里查询某一固定前缀(k1)的key
1.keys k1*    一次性返回数据量太大
2.scan 增量迭代式的命令，
scan 0 MATCH 11*  因为这里没有指定count，所以默认为10
scan 176 MATCH 11* COUNT 1000
limit a,b
limit 3,2  第几个位置开始索引，索引位置从0开始计算。第二个参数是取记录个数【4,5两个记录】

mp:  最差  最好 平均

        on2  on  on2   稳定 

选择：on2  on2  on2 不稳定

插入： on2  on  on2  稳定

快排  on2   ologn  ologn  不稳定   ologn

堆  ologn  olgn  ologn   不稳定

聚集索引和非聚集索引的区别

1.聚集索引只有一个 非聚集索引可以多个

2.聚集索引索引的顺序和物理存储顺序一致   非聚集索引的不同

3.聚集索引的叶子结点存储的索引和数据行数据，一个文件存储

非聚集索引的叶子结点存储的索引和具体所银行的地址  二哥文件存储
四种隔离级别怎么实现的（锁+Mvcc实现的）
读未提交：  select语句不加锁，每次都是最新的数据
写加行锁

读已提交：
select 使用mvcc的快照读，生成readview时机不同 
修改操作使用行锁

可重复读：
select mvcc快照读
修改 使用临检锁（行锁+间隙锁）

串行化：读写都会加锁

重写Arrays.sort方法 比较两个String字符串 使用的compareTo比较   数字可直接使用- 进行比较

        Arrays.sort(cur,(String a, String b)->{
            return (a+b)pareTo(b+a);
        });

    //字符串按照字母排序  先toCharArray()  然后Arrays.sort();  之后使用new String 即可完成排序
        String s="sdsa";
        char [] chs = s.toCharArray();
        Arrays.sort(chs);
        s = new String(chs);
        //trim 去掉收尾空格   split以什么分割开
        String[] intern = s.trim().split(" ");

threadlocal 使用开放地址法 - 线性探测法：当前哈希槽有其他对象占了，顺着数组索引寻找下一个，直到找到为止

hashset 中调用 hashmap 来存储数据的，hashmap 采用的链地址法：当哈希槽中有其他对象了，使用链表的方式连接到那个对象上

ThreadLocalMap中使用开放地址法来处理散列冲突，而HashMap中使用的是分离链表法。之所以采用不同的方式主要是因为：在ThreadLocalMap中的散列值分散得十分均匀，很少会出现冲突。
并且ThreadLocalMap经常需要清除无用的对象，使用纯数组更加方便。
ThreadLocalMap通过key（ThreadLocal类型）的hashcode来计算数组存储的索引位置i。如果i位置已经存储了对象，那么就往后挪一个位置依次类推，直到找到空的位置，再将对象存放。另外，在最后还需要判断一下当前的存储的对象个数是否已经超出了阈值（threshold的值）大小，如果超出了，需要重新扩充并将所有的对象重新计算位置。

HashSet是怎么去重的
根据key获得hash值 然后取余数组长度 获得数组下标，为null的话直接加入，不为null的话equals比较，相同就不存进去，不同直接存入 链表 
拉链法解决hash冲突

hashmap的put方法：根据key二次hash{key.hashcode异或key.hash右移16为然后与上数组长度-1}相当于取余的操作   ，扎到对应的key，为null直接加入，不为null的话 依次equals链表元素，如果一只替换元素的值，链表长度8 数组到64才会转换为红黑树， 小于64优先进行扩容处理，因为扩容就可以实现链表长度的剪短

union将两个查询结果去重保存

union all 不去重保存
CROSS JOIN生成笛卡尔积
inner join 相等查询

left join 左连接
 hashmap怎么删除元素？
remove 方法

两个join某些情况都可以使用
装箱  Integer.valueOf（）
Integer.parseInt(String的);
为什么b+数 不用红黑树  io次数为什么少（多叉平衡树）
1.b+树 非叶子节点只存储索引，叶子结点存储内容 ，同样的一个磁盘页可以存更多的数据（每页16kb，每个节点就是一个内存页16kb），磁盘io次数更少 是个多路平衡树
b树 非叶子结点也存储数据 所以说存的数据更少  层数更多 磁盘io更多
叶子结点有个双向指针只需要扫一遍即可   b树还需要去中序遍历查询

2.b+树磁盘io固定的而更加稳定  红黑树和b树不稳定 层数会更多

3.b+树是多路平衡树，红黑树是二叉树 所以b+树io次数会更少
4.不用hash索引，hash底层使用的哈希表实现的等值查询，不能排序的操作，可能hash冲突

覆盖索引：就是查询的字段在索引上直接查出来，不需要回表的操作，回表的操作就是在二级索引查到了主键id（索引值）然后去主键索引查具体的数据行 
当前会议udp  头部  还有怎么控制的udp当前会议的实时性   udp 头部 源端口 目的端口 长度 检验和
源端口 目的端口 长度 校验和

读已提交和可重复读都是使用MVCC实现的并发控制
怎么实现的并发控制 
readview+undolog版本链
实现这个  区别在readview的生成时机不同
读已提交：每次select都会创建新的readview 保证读取到已提交的修改
可重复读：在一个事务范围内，只有在第一次select的时候会更新这个readview，以后不在更新这个复用这个readview
可重复读使用的mvcc实现的幻读
没有完全解决：两个快照读中间加个当前读就会出现幻读的情况 ，更新（当前读）使mvcc版本失效了，出现了幻读
开始查询 然后另外一个修改了数据行，当前再去修改的话 在查询就是出现了幻读
nacos feign的底层协议（对http协议的一种封装）

解决接口的幂等性：
1.使用token字段放入redis
2.唯一id(比如自己的手机号)[会访问db 效率问题]
3.乐观锁加个version字段[先查版本号 然后并发修改 肯定只能一个成功]
4.可以设置状态字段保证幂等性（比如项目中的延迟队列中的解锁库存 必须判断库存表处于锁定状态而且订单处于关闭状态）

解决hash冲突：
1.开放地址法（线性探测和二次探测）
2.链地址法    
3.再hash法

1.算法
2.rabbitmq知识点
3.项目复习
4.os重要知识点

redis中的大key 怎么解决
1.比如String类型的把它分为几个key 分开
2.hash的话就是把当前对象属性都分布到field上  取的时候只取需要的字段 防止取的数据量太大 阻塞主主线程的使用

exist 和 in
exist 内大好
in 外大好
exist的话首先计算外表   然后带入内循环依次判断是否正确
in首先遍历里边的sql 生成一个表 然后去匹配外边的数据

int 1 和 int 10的区别
数字和存储空间无关 都是4byte
int(数字) 只有跟zerofill结合 才能展示准确的位数 否则显示都出不来{少于这个时可以在前边补上，超过了按照原样输出}

如何避免全表扫描
1.就是索引失效的情况
避免使用or时左右没有索引 
避免使用like% %
避免使用《》 ！=
避免使用索引列进行计算
避免索引列为char类型的=后边不适用‘’
不符合最左前缀原则的

约定大于配置
就是原来有一些固定的约定，如果不使用这些约定的话 可以自己设置替换他 尽可能的减少了默认配置

创建一个spring注解
@Target({ElementType.METHOD,ElementType.FIELD}) //用在什么地方 一般用在方法
@Retention(RetentionPolicy.RUNTIME)  //运行时运行
public @interface zhujie {
    String value() default "";
}

对象头三部分
头部（有个threadid在synchronized修改的时候去使用
有个4个bit位存储 标识年轻代晋升老年代的年龄阈值字段（jvm的分代年龄）  ）+实例变量+填充字节

```````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````
mysql的分层   连接层 服务层 存储引擎层
```````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````
各种bufferpool  和 changebuffer     write  buffer 
bufferpool 是innodb存储殷勤的缓冲池，不属于mysql的server层，主要存储数据页和(写缓冲)changebuffer,用来存储变更记录
​ 如果每次写操作，数据库都直接更新磁盘中的数据，会很占磁盘IO。为了减少磁盘IO，InnoDB在Buffer Pool中开辟了一块内存，用来存储变更记录，为了防止异常宕机丢失缓存，当事务提交时会将变更记录持久化到磁盘（redo log），等待时机更新磁盘的数据文件（刷脏），用来缓存写操作的内存，就是Change Buffer

唯一索引和普通索引怎么选择
普通索引可以重复，唯一索引只能是唯一的一个可以为空
主键索引不能为空，因为他就是聚簇索引排列的，这也就是为啥主键不能为null

如果是查询操作的话，查询会以页为单位将数据页加载进内存，bufferpool缓冲池

唯一索引根据条件查询到等值记录直接返回
普通索引会查到后，依然向后遍历  直到不满足条件的
范围查询的话 都是访问到不满足条件的值为止
但是都在内存中，所以性能几乎一致

修改操作的话
唯一索引需要检查唯一性 必须加载到内存中进行判断，直接操作内存
普通索引若数据页在内存中的直接更新
不在的话直接写到changebuffer中也可以
否则就先把更新操作记录到channge buffer 中，等下一次查询将数据读到内存中在进行 channge buffer里相关更新操作后把数据返回，等查询来了才将数据更改操作读到内存中去修改
这样在写多读少的情况下，普通索引减少了磁盘io 

aqs  （底层是双向链表队列 

他存的是节点之间的关联关系，aqs将每条请求共享资源的thread封装成一个clh队列的一个节点来实现锁的分配
1.如果需要在aqs等待队列删除一个线程node节点 方便删除
2.方便唤醒，如果是单向的话有个pre aqs在获取锁时如果获取不到进入等待状态，此时后续节点因为阻塞了无法感知前个node节点的状态，无法唤醒，所以使用双端队列加入了个next属性 方便前个节点释放后主动唤醒后续的节点thread
）   tryacquire   tryrelease   

当共享资源被某个线程占有，其他请求该资源的thread会被阻塞，从而进入一个等待队列
抽象队列同步器 是个父接口  比如reentrantLock  semaphore countdownlatch 
cyclicbirrer 实现依靠reentrantlock 和 condition实现的 
他有个state属性  使用的cas的方式进行修改属性值  aqs主要有两种形式的锁 独占锁和共享锁
如果是独占锁 state=1的时候，然后后边的话在想进入就会进入双端链表的等待队列
他的唤醒和挂起使用的底层为park和unpark的机制进行  锁的

http断点续传

HTTP1.1协议（RFC2616）中定义了断点续传相关的HTTP头 Range和Content-Range字段，一个最简单的断点续传实现大概如下
1. 客户端下载一个1024K的文件，已经下载了其中512K
2. 网络中断，客户端请求续传，因此需要在HTTP头中申明本次需要续传的片段：Range:bytes=512000-，这个头通知服务端从文件的512K位置开始传输文件；
3. 服务端收到断点续传请求，根据请求头的Content-Range来决定从文件流的哪个位置上开始读，比如从文件的512K位置开始传输，并且在HTTP头中增加：Content-Range:bytes 512000-/1024000，并且此时服务端返回的HTTP状态码应该是206，而不是200。
但是在实际场景中，会出现一种情况，即在终端发起续传请求时，URL对应的文件内容在服务端已经发生变化，此时续传的数据肯定是错误的。如何解决这个问题了？
同时定义有一个If-Range头，终端如果在续传是使用If-Range。If-Range中的内容可以为最初收到的ETag头或者是Last-Modfied中的最后修改时候。服务端在收到续传请求时，通过If-Range中的内容进行校验，校验一致时返回206的续传回应，不一致时服务端则返回200回应，回应的内容为新的文件的全部数据。

先行发生原则（happens-before规则）

//ahapp b  主要就是保障a的结果对b是可见的一整套规则。 但是时间上没有关系

：主要判断数据是否存在竞争、线程是否安全。

如果A happens-before B，仅保证A的操作结果对B可见，但并不意味着A一定比B先执行；在不影响结果的前提下，B有可能会比A先执行。

Mysql主从读写分离
主库写 从库读
1.主库执行sql修改 
2.主库成功修改时binlog更新
3.主库的binlog dump线程将更新部分发给从库
4.从库io thread收到binlog更新部分写入relay log中
5.从库读取relay log内容

并且ROW模式的binlog记录了完整的变更信息，在恢复数据上面将会很容易。

mysql慢查询优化：
1.查询慢查询查询日志定位sql
2.使用explain进行分析

rabbitmq 
RabbitMQ一般用来干嘛？你在项目中怎么用的？消息重复消费怎么办？丢失怎么办？

反射优点：增强代码的灵活性  ，比入jdk动态代理，不需要更改代码；return newproxy  根据类.getclass（）.getClassLoader（），.interface  动态获得对象的类加载器和接口

反射缺点：不安全，可以获取哪些private的属性，不像被外界直接调用的属性

如何破坏单例  【反射   序列化机制 克隆】
 都是通过构造器重新创建的
 Constructor constructor=DeclaredConstructor(null);
        constructor.setAccessible(true);
//序列化会通过反射调用无参数的构造方法创建一个新的对象。
序列化实现seriallable接口 和 clone  都不会调用构造方法

2.

1.自己的特点      注意说技术的特点，
自我介绍太啰嗦吧，把技术和项目放在自我介绍会好一点
废话多了好像，应该着重说自己会的东西

如何判断线程池的任务是否都执行完了？
1.线程池有个isTerminated的原生函数，直接判断
2.countdownlatch 任务执行完毕后执行countdown  直到最后为0 继续执行await后边的代码逻辑
3.submit提交线程任务，有个future的返回值，通过isDone（）方法可以知道任务是否执行了

treemap 和hashmap区别   都不是线程安全的
1.都实现了AbstractMap接口 treemap实现了SortedMap接口 可以对key 进行排序,默认对key进行升序排序
2.hashmap数组加链表加红黑树
3.hashmap适用于对map的插入和删除和查找元素
    trreemap适用于自然顺序遍历key的排序
hashmap中的排列顺序是不固定的

2.网络 http1  http2
1.x文本传输 
2.x 二进制进行传输
http1   
请求行 
请求头
空行
请求体
io多路复用 一次连接可以多个请求或者响应
压缩头部  客户端服务端记录发送过的  相同的不会重复发送
流式的概念   以前都是服务端等待客户端请求，现在可以服务端主动发送给客户端，减少了等待延迟

队头阻塞：
http1.1  有高延迟，页面加载速度降低，队头阻塞导致带宽无法充分利用
当顺序发送的请求序列一个请求阻塞时，后面排队的所有请求会一并被阻塞，导致客户端迟迟收不到数据
http1.0和http1.1的区别
1.0使用的短连接，每个http操作建立一个连接，结合就会释放连接
1.1使用场链接  tcp连接复用
1.1增加了host字段  可以实现单ip多个主机的实现
1.1增加了更多的缓存方式
1.0有带宽浪费的现象，想要获取对象的一部分的话只能全部都发送出去
1.1的话使用的是，可以获取指定的部分
2222222222
b+树的时间复杂度   Olog(m)n
别的红黑树等等都是二叉树

innodb 聚集索引
聚集索引叶子结点存储当前数据行的数据
二级索引叶子结点存储主键id和索引值

myisam（非聚集索引）的索引
主键索引和二级索引一致
叶子结点存储的键为索引的值 数据为索引所在行的地址

间隙锁
1.唯一索引和普通索引的非等值查询都会生成间隙锁
2.或者是在唯一索引的范围查询会生成间隙锁的生成
3.非唯一索引的等值查询也会生成间隙锁  【左边左开右闭   右边同时也会有个间隙锁的生成】

行锁：
主键索引或者唯一索引的等值操作

临检锁：

间隙锁的目的 防止幻读
1.防止间隙内插入新的数据
2.防止更新间隙内的数据

next-key锁
next-key锁其实包含了记录锁和间隙锁，即锁定一个范围，并且锁定记录本身，InnoDB默认加锁方式是next-key 锁。

nextkey锁  需要更加理解一下 不是行锁+间隙锁

案例：一张表t id(主键)、c(普通索引)、d 字段 插入数据(0,0,0),(5,5,5),(10,10,10),(15,15,15
05】 5 10】 10 15】15，+无穷】
间隙锁：
1.唯一索引和非唯一索引 不存在的指定行的加锁都变为间隙锁 
update t set d=1 where id = 7 主键索引上的 (5,10)间隙锁
update t set d=1 where c = 7 普通索引上的 (5,10)间隙锁  

2.普通索引的等值查询（查到的），向右遍历时最后一个值不满足时，next key lock退化为间隙锁
update t set d=1 where c = 5 普通索引上的 (0,5]临键锁 (5,10)间隙锁

唯一索引上不存在临检锁
3.唯一索引的范围查询  考虑是否存在当前临检锁右边的元素                     有选择的选取行锁，但是普通索引是全部的无脑临检锁
update t set d=1 where id >=10  10的行锁 10,+无穷的间隙锁
where id >=10 and id <11    主键索引上的 10行锁 (10,15)间隙锁 
 
4.普通锁引的范围查询  【普通索引都会前个区间加上后个区间】都是临检锁
update t set d=1 where c >=10 普通索引上的 (5,10]临键锁 (10,~]的临键锁
update t set d=1 where c >=10 and c <11 普通索引上的 (5,15]临键锁
update t set d=1 where c <11 普通索引上的 (0,15]临键锁
普通索引只有在等值查询的下个区间或者非等值查询才会临建锁变为间隙锁，    范围查询都是临检锁

 
费唯一索引的范围查询 锁住多个区间 
唯一索引上不存在临检锁

lock in share 读共享锁
for uodate 蟹排他

作者：小丸子的呆地
链接：
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

mvcc实现读已提交和可重复读的并发控制的区别
生成readview的时机不同，读已提交的话只要提交事务readview就会修改
可重复读的情况下一个事务范围内只有在第一次查询生成readview 后边一个事务内不会有修改

ForkJoin

get 操作不会阻塞  因为节点的value和next都是volatile的可见的

synchronized 会在扩容【forwardingNode 锁节点】和产生hash冲突  cas添加元素
cas添加元素替换替换元素

看旧的数组 有个forwardingNode标志
concurrentHashMap多线程扩容
和hashmap一致
1.链表长度到8  数组长度没到64  进行扩容
2.数组数据存放到了阈值
3.putall方法 可能上来就扩容

扩容为原数组的两倍
1.给thread分配任务  2.把转以后的节点设置为forwardingNode
首先从后边16个当前thread的，转移后当前节点就变成了ForwardingNode ，第二个thread的话从前边16开始领取16个hash桶
如果当前位置有数据 加上synchronized进行拷贝到新的数组，并且将当前节点设置为ForwardingNode
如果某个thread执行完成后，发现没了hash同，停止
jdk8采用多线程扩容【每个thread16个hash桶】
forwardingNode 标志为旧数组中处理过的节点，然后使用新的数组替换旧的数组

put过程：首先根据key求hash值然后看当前位值是否为null  为null通过cas插入元素
不位null的话 就会synchronized给这个节点上锁，然后判断加入元素，相同替换 不同加入

扩容也会给这个节点加锁
若果put过程中正在扩容的话，（扩容从后到前遍历扩容，转移走的节点标志为forwardingNode）
1.如果在forwardingNode节点之前的put 可以进行put
2.如果在当前正在扩容的节点会阻塞住该节点
3.在forwardingNode的节点put 就会帮助当前thread并发扩容

【什么情况下不会协助扩容】
1.当原数组所有节点都已经称为了forwardingNode 所有的节点都已经转移完了，
2.或者put的正在转移
3.或者达到了最大扩容线程数

1.8
hashMap扩容是怎么实现的
生成一个新数组一倍的，然后去判断转移元素
数组容量扩大一倍的话  n-1的话就会左边多出一个1
对应hash&就数组容量  如果是1现在的容量就是  旧的容量+原位置
如果是0的话当前的为值还是旧的位置

1.7扩容有两个条件
1.达到了扩容阈值
2.必须下一个插入的元素产生hash冲突才会进行扩容，如果没有产生冲突的话 还是不会扩容

红黑树（二叉树）时间复杂度 OlogN  链表 On
为什么小于64链表长度大于8为什么先扩容
数组比较小先扩容（节点的转移）就可以把长链表转换为短链表，比转换成红黑树的效率更高

40分钟
spring初始化是干嘛的（主要进行aop操作的）初始化前可以执行@postconstruct的方法

新生代和老年代为什么使用不同的算法
新生代对象很快就会回收掉
老年代对象很难回收  所以算法不同

索引的合适的情况：1.经常需要where查询的字段 ，这样走索引

2.经常需要查询的字段 使用覆盖索引

不合适的情况：1.区分度不高的

2.经常需要修改的字段

udp 源端口 目的端口 udp报文长度 校验和

tcp 源端口 目的端口 序号  确认序号

jvm的类加载机制主要有3种：全盘委托、双亲委派，缓存
全盘委派：就是当一个类加载器负责加载某个Class时，该Class所依赖和引用其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入。
双亲委派：所谓的双亲委派，则是先让父类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类。通俗的讲，就是某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父加载器，依次递归，如果父加载器可以完成类加载任务，就成功返回；只有父加载器无法完成此加载任务时，才自己去加载。
缓存机制。缓存机制将会保证所有加载过的Class都会被缓存，当程序中需要使用某个Class时，类加载器先从缓存区中搜寻该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存入缓冲区中。这就是为很么修改了Class后，必须重新启动JVM，程序所做的修改才会生效的原因。
————————————————

tomcat利用自定义的类加载器实现了热加载
WebAppClassLoad类加载实例+A类名  修改时间  一个thread一直监控类 class文件 修改就会重新创建一个WebAppClassLocader类加载器 ，等到再需要A类 时使用新的类加载器加载

热加载（不重启服务的情况下让更改的代码生效，一个thread一直监控类 class文件 修改就会加载他）（tomcat类加载的）

jvm调优
布隆过滤器（redis整合）
位图 解决缓存穿透
首先在加入元素的时候key会经过多次hash 去吧位图对应位置设置为1
然后的话查询的时候先根据hash去查当前key对应位图位置是否为1 为1的话直接查询redis缓存，不为1的话就是说明不存在这个值直接返回，并且设置缓存空值；

压测接口+秒杀？
反射？

/
力扣中注意  组合 和 子集的区别
组合 第一个if中去添加到res集合
子集是 循环中去添加res集合中
只有可以排序的才可以使用a[i]==a[i-1]去使用去重的操作

求最长递增子序列 只求长度的话dp就可
求具体的子序列需要使用回溯  遍历完全部的

全排列 需要使用个boolean数组 来判断单条链上的所有使用过的元素
区间问题想到Arrays.sort 排序数组

3.

java内存模型 就是多线程访问下保证共享变量原子性可见性 有序性的一些规则。一般共享变量存在主存中，其他thread在修改他时，读取一份共享变量的副本放到自己的工作内存，然后修改完后同步到驻村。

juc jvm
redis 和 spring

redeview的最小事务id 和 最大事务id

AQS的一些基础知识
如果state等于0，那么获取锁并将state设置为1。
如果state不等于0，但是当前线程就是加锁线程，那么获取锁定资源，并把state+1
否则，调用LockSupport.park(this)，把当前线程挂起。

可重入锁：表示当前线程获取锁后，再次获取锁不需要阻塞
当 state>0 时，表示已经有线程获得了锁，也就是 state=1，但是因为ReentrantLock 允许重入，所以同一个线程多次获得同步锁的时候，state 会递增，比如重入 5 次，那么 state=5。 而在释放锁的时候，同样需要释放 5 次直到 state=0其他线程才有资格获得锁。

synchronized的可重入锁的实现原理：

每一个锁关联一个线程持有者和计数器，当计数器为 0 时表示该锁没有被任何线程持有，那么任何线程都可能获得该锁而调用相应的方法；当某一线程请求成功后，JVM会记下锁的持有线程，并且将计数器置为 1；此时其它线程请求该锁，则必须等待；而该持有锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会递增；当线程退出同步代码块时，计数器会递减，如果计数器为 0，则释放该锁。
————————————————
  =============================================
syncgronized的加锁原理：
进入同步代码块 执行monitorenter指令，视图获取当前monitor对象，然后去看内部的一个计数器，如果为0就获取该锁然后+1，直到执行了monitorexit指令才会退出当前同步代码快，别的阻塞的thread放入到entrylist等待队列等待
如果是放在方法上的，synchronized会给方法加一个acc标识，代表当前方法为同步方法

Reentrantlock加锁的流程：因为分为公平锁和非公平锁
公平锁的话，调用tryAcquire加锁的时候先去看state是否为0，是的话去看双向链表中有没有thread在等待，有的话使用LockSupport.park()把当前thread挂起加入队尾，没有的话执行thread加锁
解锁的话调用tryRelease成功的话唤型等待队列中的thread  
失败的话直接返回false

非公平锁的话，加锁的话直接尝试把状态设置state为1，成功获取锁，否则去获取state值，0的话直接获取锁，不管队列中还有没有thread在等待，不等于0的话放入队尾
非公平锁加锁过程不同于FairSync，NonFairSync会在调用lock()时，直接尝试把state设置为1：

解锁的话调用tryRelease（）成功的话    使用LockSupport.unpark唤醒等待队列中的thread  
失败的话直接返回false

aqs  （底层是双向链表队列） 
AQS（AbstractQueuedSynchronizer）是抽象队列同步器，在线程访问共享资源时候，会先判断资源是否上锁了，
如果上锁了，那么把该线程放入fifo的双向链表中进行等待；
如果没上锁，非公平锁那么把该线程设置为工作线程，公平锁会从双向链表中唤醒第一个节点thread，并且把自己放到双向链表尾部

AQS 队列内部维护的是一个 FIFO 的双向链表，双向链表可以从任意一个节点开始很方便的访问前驱和后继。每个 Node 其实是由线程封装，当线程争抢锁失败后会封装成 Node 加入到 ASQ 队列中去；当获取锁的线程释放锁以后，会从队列中唤醒一个阻塞的节点(线程)。
————————————————
aqs为什么使用双向链表（但是仍然是fifo的）？ 中断操作方便+主动唤醒下一个节点

1.中断操作需要在aqs队列中删除thread的Node节点，如果需要在aqs等待队列删除一个线程node节点 方便删除
2.方便主动唤醒，如果是单向的话有个pre aqs在获取锁时如果获取不到进入等待状态，此时后续节点因为阻塞了无法感知前个node节点的状态，无法唤醒，所以使用双端队列加入了个next属性 方便前个节点释放后主动唤醒后续的节点thread
  tryacquire（）获取锁     tryrelease   （）释放锁

reentrantLock的可中断
ReentrantLock中的lockInterruptibly()方法使得线程可以在被阻塞时响应中断，比如一个线程t1通过lockInterruptibly()方法获取到一个可重入锁，并执行一个长时间的任务，另一个线程通过interrupt()方法就可以立刻打断t1线程的执行，来获取t1持有的那个可重入锁。而通过ReentrantLock的lock()方法或者Synchronized持有锁的线程是不会响应其他线程的interrupt()方法的，直到该方法主动释放锁之后才会响应interrupt()方法。
————————————————

当共享资源被某个线程占有，其他请求该资源的thread会被阻塞，从而进入一个双向链表的等待队列
抽象队列同步器 是个父接口  比如reentrantLock  semaphore countdownlatch 
cyclicbirrer 实现依靠reentrantlock 和 condition实现的 
他有个volatile修饰的state属性  使用的cas的方式进行修改属性值  aqs主要有两种形式的锁 独占锁（synchronized和rerntrantlock）和共享锁
 state=1的时候，然后后边的话在想进入就会进入双向链表的等待队列尾部
他的解锁上锁使用的底层为park和unpark的机制进行thread的挂起和唤醒

————————————————————————————————————————————————————————

各种bufferpool  和 changebuffer                       write  buffer 
bufferpool 是innodb存储殷勤的缓冲池，不属于mysql的server层，主要存储数据页和(写缓冲)changebuffer,用来存储变更记录
​ 如果每次写操作，数据库都直接更新磁盘中的数据，会很占磁盘IO。为了减少磁盘IO，InnoDB在Buffer Pool中开辟了一块内存，用来存储变更记录，为了防止异常宕机丢失缓存，当事务提交时会将变更记录持久化到磁盘（redo log），等待时机更新磁盘的数据文件（刷脏），用来缓存写操作的内存，就是Change Buffer

————————————————
处理数据库死锁问题
间隙锁和next-key lock的引入，解决了幻读的问题，但同时也带来了一些困扰
1.sessionA执行select … for update语句，由于id=9这一行并不存在，因此会加上间隙锁(5,10)

2.sessionB执行select … for update语句，同样会加上间隙锁(5,10)，间隙锁之间不会冲突

3.sessionB试图插入一行(9,9,9)，被sessionA的间隙锁挡住了，只好进入等待

4.sessionA试图插入一行(9,9,9)，被sessionB的间隙锁挡住了

两个session进入互相等待状态，形成了死锁

间隙锁是在可重复读隔离级别下才会生效的。所以，你如果把隔离级别设置为读已提交的话，就没有间隙锁了。但同时，你要解决可能出现的数据和日志不一致问题，需要把 binlog 格式设置为 row（记录每行的修改记录）。
————————————————
快照读：读取的是快照版本。普通的SELECT就是快照读。通过mvcc来进行并发控制的，不用加锁。
当前读：读取的是最新版本。UPDATE、DELETE、INSERT、SELECT … LOCK IN SHARE MODE、SELECT … FOR UPDATE是当前读。
锁还不太清晰，何时间隙锁和临检所
使用next key锁不能完全解决幻读问题，当当前读和快照读同时发生
两次快照读中间一次当前读操作                     更新（当前读）使mvcc版本失效了，出现了幻读

java为什么不支持多继承
单继承的话子类可以修改父类的某个方法进行重写，
如果c继承a 和 b 两个类都有同个方法，c去调用这个方法时就无法确定调用哪个
多继承不可以但是可以多实现  实现多个接口，

接口为什么加入了默认方法？
因为多个普通的类实现了接口，扩展增加接口方法所有的实现类必须全部重写这个方法，
因此加入了默认方法就不用去全部重写，方便接口的扩展

冒泡

class Solution {
    List<String> rec;
    boolean[] vis;

    public String[] permutation(String s) {
        int n = s.length();
        rec = new ArrayList<String>();
        vis = new boolean[n];
        char[] arr = s.toCharArray();
        Arrays.sort(arr);
        StringBuffer perm = new StringBuffer();
        backtrack(arr, 0, n, perm);
        int size = rec.size();
        String[] recArr = new String[size];
        for (int i = 0; i < size; i++) {
            recArr[i] = (i);
        }
        return recArr;
    }

    public void backtrack(char[] arr, int i, int n, StringBuffer perm) {
        if (i == n) {
            rec.String());
            return;
        }
        for (int j = 0; j < n; j++) {
            if (vis[j] || (j > 0 && !vis[j - 1] && arr[j - 1] == arr[j])) {
                continue;
            }
            vis[j] = true;
            perm.append(arr[j]);
            backtrack(arr, i + 1, n, perm);
            perm.deleteCharAt(perm.length() - 1);
            vis[j] = false;
        }
    }
}

4.

重点 93复原ip
和接雨水
105 从前序与中序遍历序列构造二叉树
三个树遍历的迭代写法
Lru 缓存  
LFU？
二叉树中和为某个值的路径  【注意叶子结点的地方不能写return ，因为需要回溯】
最长公共子数组  最长公共子序列  b编辑距离 使用二维dp n+1  m+1
重排链表（首先根据链表中间节点分成两半，之后一致分到只有单节点【==null】 return    之后 return merage（）两个节点    最后合并为一个正的链表）     归并排序  1.中间节点  2.
insert into student(name , age)values(' andy' ,20);

delete from user where id > 4;

update user set username  = '百里守约',description = '玄策的哥哥';

update u set cid = 01 where name = 'zs';

tail -f -n10 文件
端口被哪个进程占用

neetstart tunlp|grep 20
neststat tunlp|grep 10

端口是否监听
neatstat anp|grep 端口
CREATE TABLE Person 

(

LastName varchar,

FirstName varchar,

Address varchar,

Age int

)

别的区别：：：：：：： 
StringBuffer每次获取toString都会直接使用缓存区的 toStringCache值(，一旦StringBuffer被修改就清除这个缓存值。)来构造一个字符串。StringBuilder 则每次都需要复制一次字符数组，再构造一个字符串。所以说StringBuffer利用缓存区进行了部分优化操作。

状态码304，502，504什么含义
502网关错误    504网关超时

301 永久重定向

302 临时重定向
304 自从上次请求后，网址内容没有修改过，服务器不会返回网页的内容，直接使用本地资源即可
502服务器作为网关出错       从上游服务器收到了无效的响应
504服务器作为网关超时了    没有及时收到上游服务器的响应

DNS劫持：攻击dns服务器然后修改域名服务器中的dns缓存让他跳转到错误的网页。
如何预防呢？
通过防火墙限制外来的访问
大部分攻击是通过恶意软件/木马病毒进行攻击，有意避开病毒网站提高服务器安全性。

发生劫持了可以这样：
修改hosts文件，操作系统中Hosts文件的权限优先级高于DNS服务器，
操作系统在访问某个域名时，会先检测HOSTS文件，然后再查询DNS服务器。可以在hosts添加受到污染的DNS地址来解决DNS污染和DNS劫持。

linux沙雕一个进程（查看全部进程和进程id   kill沙雕具体的进程id）
ps -ef|grep 某个程序
kill 他的进程id 
kill -9 强制杀死 带有强制执行的意思
然后kill

linux如何查看端口被哪个进程占用
netstat -tunlp|grep 端口号

查看端口是否被占用（listen 状态）
netstat -anp|grep 端口号 

tail-f -n 10 查看最近10行的日志

查看磁盘占用情况   du -h 查看每个根目录的分区大小

内存占用情况：free 查询

建造者模式说一下  builder

myisam和innodb索引的区别                
没有条件的count(*) myisam比innodb快的多，因为myisam有个计数器 可以更快的查询计数
m的主键索引叶子结点具体行数据，二级索引存储的是主键值+索引值
in 的主键和二级索引都是存储的对应数据行的指针，所以他是两个文件
myisam 适合读多写少的场景

1.行锁表锁  表锁

2.支持mvcc并发控制

3.支持事务，可以事务回滚

4.m的count操作，特有一个记录，不用查询，直接返回，i需要去查询

5.支持外键 

redis持久化方式，重启时，master和slave读取RDB有什么不同
主节点直接读取reb文件重启
从节点比较runid  是否为上个主节点，runid不同的话直接全量复制
offset和主节点唤醒缓冲区的差值，如果超过唤醒缓冲区直接全量复制，没有的话直接增量复制

rdb 和 aof 

7成环 2个thread同时扩容，首先第一个thread把 当前第一个节点转到头结点，然后把第二个节点转到头结点 ，此时变成了21 倒叙，另外一个thread 要把1节点指向链表头结点2所以形成了死链。

jdk7 和jdk8的扩容区别啊
底层数据结构不一样，1.7是数组+链表，1.8则是数组+链表+红黑树结构（当链表长度大于8，转为红黑树）。
JDK1.7用的是头插法，而JDK1.8及之后使用的都是尾插法，那么他们为什么要这样做呢？
为什么开始使用头插法？开始考虑的后插入的元素使用频率会更高容易查找，但是扩容的话会逆序循环死链等问题。
因为JDK1.7是用单链表进行的纵向延伸，当采用头插法时会容易出现逆序且环形链表死循环问题。但是在JDK1.8之后是因为加入了红黑树使用尾插法，能够避免出现逆序且链表死循环的问题。
————————————————
版权声明：本文为CSDN博主「李昊轩的博客」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：
为什么与上2的n次方 求位置的时候，只有这样的话-1就是全1，最大程度减少hash碰撞
因为为了求下标的时候方便查找下标，并且位运算速度快，-1之后为全1减少了hash碰撞
求节点的位置：hash值异或上这个hash右移16位然后与上数组长度-1（相当于取余操作）
7：先扩容后插入  8：先插入后扩容

resize 【创建新的数组 然后迁移节点到新的位置】 扩容                  rehash 
jdk7的话插入达到阈值如果没有产生hash冲突会直接插入这个位置，直到产生hash冲突才会进行扩容
jdk8到了阈值直接扩容
扩容判断有区别啊：
7的话是hash值    与上   新数组长度－1
8的时候使用这个
hash与旧数组长度为0 位置不变 
为1的话长度变为原位置+原数组长度

计算key的位置的值 jdk8  key.hash^(h>>>16)&(length-1)  

为什么null在第一个位置？
因为null的hash值为0 索引只能存储在第一个位置
hashmap方null  hashtable不可以的 con 也不可以

Redis AOF不也要把日志写到磁盘么，那和MySQL的IO有啥区别，凭啥Redis就快

因为redis aof只有在写入磁盘的时候才会有磁盘io  读写还是在内存   
mysql是读写都需要磁盘io 

分库分表 ： 连接数过多的 只能分库了  分表是单表数据量太大

垂直查分表的话：根据业务进行拆分的【比如商品的简介  和点击的具体详情  将两个操作解耦了 觉少了】
垂直分库： 将SELLER_DB(卖家库)，拆分为PRODUCT_DB(商品库)和STORE_DB(店铺库)

水平分库：可以把一个表的数据(按数据行)分到多个不同的库，每个库只有这个表的部分数据，这些库可以分布在不同服务器，从而使访问压力被多服务器负载，大大提升性能。它不仅需要解决跨库带来的所有复杂问题，还要解决数据路由的问题。

水平分表：可以把一个表的数据(按数据行)分到多个同一个数据库的多张表中，每个表只有这个表的部分数据，这样做能小幅提升性能，它仅仅作为水平分库的一个补充优化。

一致性hash 首先根据数据某个自增属性分到一个圆环上的某几个节点，由于可能不均匀所以设置几个虚拟节点分别对应相对应的事迹节点（采用顺时针进行存），然后再添加节点的话直接添加啊新的虚拟节点 只有这个虚拟节点和签个节点直接的数据放入到这个新添假的节点 ，不用全部替换位置。
————————————————
版权声明：本文为CSDN博主「小Y是我的」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：

关系型db和非关系型数据库的区别：
1.关系型db采用关系模型存储在二维表格中
2.非关系型db根据key value 存储在特定的数据结构中，
关系型支持事务  非关系型不支持

new FixedThreadPool 
new SingleThreadExecutor
New cCacheThreadPool

CachedThreadPool 是一个会根据需要创建新线程的线程池，
核心线程数 0 最大线程数 Integre.MAX_VALUE  阻塞队列 SynchronousQueue   最长时间 60 秒
如果主线程提交任务的速度高于 maximumPool 中线程处理任务的速度时，CachedThreadPool 会不断创建新线程。极端情况下，CachedThreadPool 会因为创建过多线程而耗尽 CPU 和内存资源。
，适用于执行很多thread的短期异步任务

1.LinkedBlockingQueue是基于链表实现的初始化是可以不用指定队列大小（默认是Integer.MAX_VALUE）；ArrayBlockingQueue是基于数组实现的初始化时必须指定队列大小

2.LinkedBlockingQueue在puts操作都会生成新的Node对象，takes操作Node对象在某一时间会被GC，可能会影响GC性能；ArrayBlockingQueue是固定的数组长度循环使用，
不会出现对象的产生与回收

3.LinkedBlockingQueue是基于链表的形式，在执行remove操作时，不用移动其他数据；ArrayBlockingQueue是基于数组，在remove时需要移动数据，影响性能

4.LinkedBlockingQueue使用两个锁将（生产者和消费者两把锁）puts操作与takes操作分开；ArrayBlockingQueue（生产者和消费者用一把锁）使用一个锁来控制，在高并发高吞吐的情况下，LinkedBlockingQueue的性能较好
————————————————

三色标记 在并打标机的阶段
完全扫描黑色，扫描到的灰色  白色没有扫描过的垃圾

并发标记重新标记：都怎摸解决漏标问题的
漏标怎么解决的？
cms：增量更新
插入了一条从黑色对象到白色对象的引用，同时去掉了从黑色对象到这个白色对象的直接引用
增量更新：记下这个黑色对象对白色对象的引用，并发标记结束后，重新标记根据新的引用重新判断

g1：原始快照（satb）
记录下这个删除引用，灰色对象到白色对象的引用，根据这个灰色对象最终标记

CREATE INDEX indexName ON mytable(username(length)); 
execute和submit 的区别
 e = wFixedThreadPool（3）；
e.execute(实现Runnable的具体的类);
1.exectue只能提交runnable的任务
submit runnable和callable的都可以
2.exectue没有返回值 submit可以有返回值
3.e 是可以直接抛出异常的
submit的这个返回的future  然后 才能捕获异常

runnable和callable的区别
重写run方法 重写call方法
返回值
runnable不能抛出异常
callable可以抛出异常
runnable可以使用newthread 和 仍如线程池使用
callable 只能放到线程池使用  furetureTask 

聚集索引 和非聚集索引

1.聚集索引存储的物理上是连续的，和索引顺序万群一致
  费聚集索引物理上是不连续的，和索引的顺序不同
2.聚集索引叶子结点是数据行记录和索引值，存储在一个文件上
费聚集索引的叶子结点是指向数据的地址和索引值，存储在两个文件，

为什么innodb表（聚集索引必须要主键）？ 没有主键去第一个非空的唯一索引，或者自己增加个隐藏的row-id
因为主键索引的聚集索引就是根据主键形成的聚集索引

自增主键的坏处?

分布式存储的数据表由于每个表都自增，导致主键冲突
高并发情况下，在innodb中插入可能会导致间隙锁之间的竞争，

对象头、{markword ，对象头的引用 gc的分代年龄4个bit 【这个gc4bit在markword中】
锁的标志位：

指向类的指针（类数据保存在方法区 class）} 
实例变量 （各种属性值） 
填充字节
    
01偏向锁 无锁  这两个的区别就是前个标志位区别  0位无锁  1位偏向锁
00 轻量级锁
10 重量级锁

LRU和LFU：
幂等性问题接口：1.使用token字段 或者（根据插入的内容）数据库唯一字段插入数据
2.数据库的唯一id  根据业务的某个值插入数据库看是否能插入    
3.字段上设置为多个状态 保证幂等性，根据状态判断是否能继续修改    
4.乐观锁 也就是加上version字段 
调表：让链表有序，然后向上每隔两个位置引出来个二级链表 一直向上引，直到最后向下根据折半查找一样查找 

IO多路复用
奇安信
网易1
网易2021提前

方法区gc的？？？？？？？？？？？？？？？？？？？？？3个条件 
方法区的垃圾回收主要有两种，分别是对废弃常量的回收（常量池的回收）和对无用类的回收（类的卸载）。

当一个常量对象不再任何地方被引用的时候，则被标记为废弃常量，这个常量可以被回收。

方法区中的类需要同时满足以下三个条件才能被标记为无用的类：
1.Java堆中不存在该类的任何实例对象；

2.加载该类的类加载器已经被回收；

3.该类对应的java.lang.Class对象不在任何地方被引用，且无法在任何地方通过反射访问该类的方法。

当满足上述三个条件的类才可以被回收，但是并不是一定会被回收，需要参数进行控制，例如HotSpot虚拟机提供了-Xnoclassgc参数进行控制是否回收。
————————————————
版权声明：本文为CSDN博主「五山口老法师」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：

redis哨兵模式：
1.监控（同步所有信息）    所有主节点然后去查看各自的从节点，将信息全都同步到烧饼节点，烧饼节点之间也是互通的
2.通知 （查看各节点状态）      烧饼节点去查看各节点是否在线，然后把状态同时通知给所有的哨兵节点
3.故障转移  当某个主节点挂了 然后当前哨兵认为他挂了，然后别的哨兵也去查看他的状态，超过半数认为他挂了就是当前节点挂了
选一个烧饼节点 
首先去选一个哨兵节点（竞选次数多的）让他去选举主节点 
1.选择在线的从节点得优先级最高的
2.如果有多个最高优先级的slave，则选取复制偏移量最大（即复制越完整）的当选
3.如果以上条件都一样，选取runid最小的slave。

优先原则：比较offset和runid

通知其他从节点选举出的新节点

关系型和非关系型数据库

1.关系型数据库基于关系模型的，数据存储在行列的表格中，

2.非关系型数据库 主要基于kv键值对的形式

1.关系型数据库存储在磁盘上，非关系型存在内存，读写速度很快

2.关系型db支持事务，redis很难完成事务操作

<resultMap type="com.ity.IntegrationChangeHistoryEntity" id="integrationChangeHistoryMap"><result property="id" column="id"/><result property="memberId" column="member_id"/><result property="createTime" column="create_time"/>