别的啊复盘

mysql主从同步为什么不使用redolog日志？

1.mysql的redolog日志属于innodb存储引擎特有的，innodb是所有引擎都具有的

2.redolog属于物理日志，记录了现有的而具有提数据，无法得知以前的操作

而binlog是逻辑日志 记录了所有的写操作，用友更具体的议案的操作，更全面

1.try catch  关闭io资源

2.try with resource 直接关闭io资源

spring的主要模块

1.核心模块也就是实现ioc的模块

2.aop模块

3.orm模块 持久层

4.mvc模块

深拷贝的三种方式

1.构造方法创建全新的对象

2.实现clone方法

3.Serializable序列化实现深拷贝

start和run的区别

1、线程中的start()方法和run()方法的主要区别在于，当程序调用start()方法，将会创建一个新线程去执行run()方法中的代码。但是如果直接调用run()方法的话，会直接在当前线程中执行run()中的代码，注意，这里不会创建新线程。这样run()就像一个普通方法一样。

2、另外当一个线程启动之后，不能重复调用start()，否则会报IllegalStateException异常。但是可以重复调用run()方法。

总结起来就是run()就是一个普通的方法，而start()会创建一个新线程去执行run()的代码。
————————————————
版权声明：本文为CSDN博主「未名湖畔种千玺」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_40649503/article/details/124556991

1. 小表驱动大表问题  select *from t1 inner join t2 on t1  = t2         
2. 这种问题因为根据这种join查询都会把前边的数据先查出来然后把前边数据存到join-buffer中，这涉及到了io操作，所以小标时间更短将join_buffer中的数据和后表中的数据进行匹配，

基于aop实现日志增强

1.设置一个日志自定义注解 

target 放在神魔地方

rentention 什么地方生效

和一些属性默认值

2.使用这个注解放在需要设置日志的地方

创建一个类加上aspect直接 去设置一些切面和方法  

配合注入@Slf4j  在需要注解的地方直接log打印

创建一个pointcut切面 确定在什么地方使用这个日志

创建一些前置通知方法 后置通知方法  和 环绕通知方法

array和arraylist的区别

1.array是数组 arraylist集合

2.array只存储基本数据类型 和 引用数据类型 

 arraylist存储 引用数据类型

3.array是订场的

arraylist是可变长度的

4.Array中存放的是同种数据类型的元素，ArrayList可以存放不同数据类型。

10G数据，1G内存，如何排序？

1.首先将数据分为10份，然后每个内部使用快速排序排序自己

2.然后创建一个10的最小堆，取10份的最小的然后再取最小的那个的下一个  【排序数组 排序链表就是这样】

3.最后拍出来的就是有序的

top  k的问题

1.通过hash将数据分散到不同文件

2.使用hashmap存储具体的数量 每个文件都创建一个k大小的小顶堆

3.分别取各个文件的k个 然后取钱k个 【全部放进去】

创建一个java对象的过程

1.首先判断类加载有没有加载过这个对象

2.没有加载过的话取加载这个对象

3.为对象进行内存分配附上默认值

4.设置对象头

5.加载初始化方法，完成一些其他的赋值

springboot 优先读取 properties文件 再去读取yml文件的信息  先读取的也不会覆盖

悲观锁：

select*from test where id = 2 for uodate

乐观锁

update test set id = 2   version = version+1 where id = 2 and version = 210 

赛码问题4

64匹马，8个赛道，选择最快4匹马最少需要多少次？

10次或11次

堆和栈的区别

1.栈操作系统自动分配 所以v快，堆认为申请的 所以v慢

2.栈空间小 堆空间大

3.栈连续的 对不连续的

6大原则：单一这则原则 理事替换原则 接口隔离原则 依赖倒置原则 开闭原则 迪米特原则

private static final  不能修饰需要重写的方法【同时也就是不能修饰abstract类的方法】

一个map，已经放了1000个key，线程1打印这1000个key值，线程1打印同时，线程2，插入1000个key（保证key都不相同），此时线程1打印情况

报错 concurrent modificationException  因为map的迭代器是fail-fast的 遍历同时不能修改

幻读：【两个select中间的update操作】

事务1；首先select  然后 事务2 uodate  此时事务1select仍然是原来的 ，但是事务1一旦update操作，就会产生幻读（换行，触发mvcc视图的更新）；

object的hashcode就是根据内存地址进行计算的

string的hashcode值：根据遍历char型数组 31*一个h+vaue【i】 一致循环计算

h = 31*h+value[i] 循环计算

equals 主要先判断== 是否地址相等

然后instanceof是否为他的实现类或子类，然后判断长度是否相等，最后通过遍历两个数组，判断是否值相等

switch语句的合适范围                                                        “byte、short、int、char、枚举 、String”

java常见的序列化方法

1.实现 Serializable 接口，

2.Json 序列化一般会使用fastjson 包

json.tojsonstring

json.parseobject（a,class）;

两种方式的区别：【被static修饰和transient修饰的成员不会被序列化，比如hashmap的Node数组】

1.Serializable 接口的序列化，除了对象的数据以外，还是包含有这个对象的类信息的。而json是只包含有单纯的数据信息。

2.接口的转换为字节流，一般用于rpc的序列化

json的一般用于前后端传输数据

properties文件和yaml配置文件的区别

1.yml文件更加简洁，properties语法是key=value 但是yml是使用key：value存储的

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版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_39025362/article/details/108003943

<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).compareTo(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缓冲池

<