JAVA中级实际面试记录干货

╰半夏微凉° 2023-07-17 04:58 19阅读 0赞

### **写在前面：该记录为实际面试提问记录，问题繁多，涉及面广，可以以这些点去扩展面的复习，祝大家早日找到心仪工作** ###

1.  **jvm Synchronized ****和** **volatile** **功能，区别和底层实现原理**
    
    1.  volatile ：防止指令重排-原理是生成内存屏障，可见性-当值发生改变会立即将值同步到主内存，不意味着线程安全，在同步过程中出现竞争；
        
        Synchronized ：原理是在同步的前后使用监视器锁
2.  **dubbo** **作用是什么，完整的调用流程**
    
    1.  什么是rpc
        
         *  是一种远程调用
         *  Rpc可以使用http协议也可以使用自定义tcp协议
    2.  什么是dubbo
        
         *  基于rpc的远程调用框架
         *  分为消费者，注册中心，服务提供者，服务运行容器和监控中心
         *  大致流程：首先服务提供者向注册中心注册提供的服务，消费者启动向注册中心订阅所需要的服务，注册中心将提供者的元数据给消费者，消费者根据负载均衡选择提供者调用，之后如果提供者元数据变更会通知消费者
    3.  服务暴露流程
        
         *  服务暴露开始于spring ioc容器刷新完毕，根据配置封装成URL，根据参数进行本地调用或远程调用
         *  会通过proxyFactory获取invoker对象，利用javassist进行动态代理封装类，然后再通过URL参数选择对应的协议进行暴露，默认时dubbo协议
         *  在第一次暴露时，会创建服务，默认是Netty
         *  获取到的信息缓存在一个map中供给之后的远程调用查找
         *  最后向注册中心注册提供者的信息
    4.  服务引入流程
        
         *  服务的引入有两种，饿汉和懒汉，饿汉是加载完毕就会引入，懒汉是当使用到这个服务时才引入
         *  先根据配置封装URL，通常使用的是注册中心，会构建RegistryDirectory,向注册中心注册消费者信息，订阅提供者，配置和路由节点
         *  根据提供者信息创建invoker对象通过netty远程通讯包装invoker,返回代理类对象
    5.  服务调用流程
        
         *  调用某个接口前会生成代理类从cluster中经过过滤和负载均衡选择一个invoker进行调用，服务端接收请求后会找到之前暴露缓存的Map,获取到相关信息返回
         *  消费者根据ID去查询之前的记录的请求，找到请求后塞到对应的线程中，消费者得到响应
    6.  什么是spi，和java spi区别
        
         *  主要时用于框架中，不同的使用者有不同的需求，spi就是指定一个特定的文件位置，记录全限定名称，获取到对应的类进行加载
         *  Java 的spi在遍历时会将配置文件的全部类加载出来，若有个类加载比较消耗资源，又没用到那么是没有必要的
    7.  为什么使用的是javassist动态代理
        
         *  很快，生成字节码方便
3.  **Synchronized jvm****优化内容**
    
    1.  锁粗化：例如在循环里内加锁，就会把锁扩大至循环体外
        
        轻量级锁：
        
        自旋锁：普通线程获取锁后，后面的线程再获取时会阻塞，将线程挂起，若竞争不激烈那么带来了上下文切换的代价高于等待资源的代价，
        
        自适应自旋锁：自旋锁有一个固定的等待次数，自适应自旋锁根据之前等待次数自适应的等待尝试
        
        锁消除：若不存在竞争直接消除锁
        
        偏向锁：若一个线程频繁持有，会将锁偏向于它
4.  **什么是轻量级锁和重量级锁，原理是什么**
    
    1.  ****
        
        轻量级锁是在makeword消息头中设置标识，内部会拷贝一份makeworld，利用cas进行加锁，出现竞争先自旋等待，若等待次数超过阈值则修改标识，此时膨胀为重量级锁；重量级锁则需要使用监视器锁，比较消耗资源
        
        无锁-->重量级锁流程：
        
        首先是无锁状态，当有单线程持频繁持有则修改标识变成偏向锁，
        
        出现竞争时，会检查当前makeworld中的状态若为偏向锁，因为偏向锁不会主动释放锁，所以会检查线程中是否存活，存活的话，会暂停当前线程，等待到达安全区的时候升级为轻量级锁，轻量级锁会拷贝makeword到锁空间，底层利用CAS来进行操作，若失败则尝试使用自旋锁来获取锁，达到阈值时，则升级位重量级锁，它会将除了拥有锁的线程全部阻塞防止cpu空转。
        
        这里锁的升级流程轻量级锁一旦膨胀为重量级锁就不会降级了
        
        CAS: 如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值 
5.  **eureka** **功能**
    
    1.  ****
        
        注册与发现
        
        消息通信用的是http协议
        
        底层实现使用过滤器进行分发，经过一系列责任链，使用concurrenthashmap存储子服务的注册信息，是一个嵌套map的结构（这里是为集群做考虑），若是注册的时候出现注册冲突，底层是根据两个服务的最后活跃时间来判断处理。
6.  **new****一个对象的原理过程**
    
    1.  ****先去常量池检查是否有符号引用，检查符号引用是否被加载和初始化，然后准备分配内存，若内存是规整排布的，则只用指针移动（指针碰撞），否则维护一张空闲表
7.  **mongodb****和****redis****区别**
    
    1.  ****mongodb更类似于mysql,能够存储海量数据，擅长查询json数据
8.  **mybatis****实现原理过程**
    
    1.  ****首先读取Mybatis配置表去加载映射文件【也就是我们实体对象的xml】，构造sqlsessionFactory，创建sqlsession对象，获取执行器Executor（解析xml）获取到执行sql
9.  **spring cloud fegin****原理流程**
    
    1.  ****
        
        feign自身带了ribbon的负载均衡，通过配置文件可以修改其默认的轮询算法
        
        原理：首先对定义了@FeignClient注解的接口创建一个动态代理，当调用这个接口则调用代理对象，根据接口上的@RequestMapping等请求注解动态的构造出服务地址，最后根据这个地址发起HTTP请求，解析http相应返回结果
        
        流程：定义一个接口，设置上@FeignClient，添加我们要调用的方法
10. **spring cloud Eureka** **原理流程，以及缓存**
    
    1.  ****
        
        原理流程：首先子服务会在注册中心注册，并将自己的服务ID,Ip,端口告诉注册中心，通过缓存注册表，子服务也有个Eureka client组件，它会询问Eureke获取到各各子组件的信息，再发生调用时就可以发送对应的请求
        
        缓存:提供了三级缓存来保存服务注册信息,registry,readWriteCacheMap,readOnlyCacheMap,默认是每隔30秒同步readWriteCacheMap-->readOnlyCacheMap,eurekaClient会周期性的去获取缓存数据，利用缓存机制，减少网络请求
11. **用来****spring cloud** **的哪些组件**
    
    1.  ****Ribbon,config,gateway,bus,Hystrix
12. **spring cloud ribbon****功能和原理**
    
    1.  主要是负载均衡，配合feign使用，使用轮询算法分配请求
        
        原理：利用ribbon利用RestTemplate的拦截器机制，在拦截器中做负载均衡，利用服务名称去注册中心获取到服务地址列表，通过负载均衡算法决定使用哪一个服务地址就行http调用
13. **spring cloud config** **能动态刷新配置**
    
    1.  ****
        
        Spring cloud提供了手动刷新:首先暴露接口，打上`@RefreshScope`注解，调用接口就可以刷新配置了
        
        自动刷新配置:使用spring cloud bus，原理是使用消息队列连接分布式节点，通知配置变化
14. **List** **遍历移除会报什么错，怎么移除**
    
    1.  ****
        
        ConcurrentModificationException，使用迭代器的方式删除
        
        普通for循环，若遍历次数定义在外部则会出现数组越界
15. **hashmap** **默认大小，扩容是扩容多大**
    
    1.  ****
        
        ConcurrentModificationException，使用迭代器的方式删除
        
        普通for循环，若遍历次数定义在外部则会出现数组越界
16. **hashmap** **线程不安全主要是在哪里**
    
    1.  ****
        
        在1.7之前扩容使用resize的transfer，由于是头插法在多线程下出现循环链表，后面的数据定位到该链表时数据丢失，读取可能导致死循环
        
        在1.8后使用尾插法，不改变原来链表顺序，在多线程情况下，put计算数组下标相同，出现值覆盖
17. **redis****和数据库不一致怎么解决，如果业务一定不一致怎么办**
    
    1.  ****
        
        1.利用懒加载的思想更新先更新数据库，再删除数据，读取先读取数据库，再写缓存（缺点如果数据大量更新频繁，会造成缓存击穿）
        
        2.可以再更新时不删除缓存，而是设置一个过期时间，会出现一定时间范围内缓存不一致
18. **Hystrix****断路器的原理和流程**
    
    1.  ****
        
        将请求单独封装到单独线程中，有自动超时策略，熔断策略来解决级联故障和服务雪崩
        
        断路器原理：通过时间窗的形式记录范围内接口请求健康状态，获取到对应的度量指标，指标不符合则断路器打开
        
        底层使用了切面技术
        
        流程
    2.  hystrix会构建一个hystrixCommand（返回单个结果）或者hystrixObservableCommand对象（返回多个结果）
    3.  选择调用方式（同步调用，异步调用，订阅观察者对象，返回观察者对象）
    4.  判断是否有缓存，有缓存直接获取缓存中的hystrixRequestContext
    5.  检查是否开启了断路器
    6.  若开启了断路器，则检查服务异常是否超过阈值，熔断拒绝该服务的所有请求，间隔一段时间再放过少量请求重试
    7.  通过断路器，执行Command命令若发生异常则再次降级
19. **创建线程的方式**
    
    1.  ****继承Thread，实现Runnable接口，利用Callable和Future创建线程
20. **线程池的主要参数**
    
    1.  ****核心线程数，最大线程数量，空闲线程存活时间，阻塞队列，线程工程，任务拒绝策略（丢弃抛异常，丢弃不抛异常，丢弃最前面的重新提交，调用线程处理）
21. **创建线程怎么获取返回值**
    
    1.  ****利用Callable和Future创建线程
22. **注解创建线程**
    
    1.  ****使用@Async，需要添加@EnableAsync注解
23. **RabbitMQ****怎么处理消息丢失**
    
    1.  ****
        
        生产者丢失：可以开启confirm确认模式
        
        消息队列丢失：消息持久化，持久化后可以给生产者发送ack确认消息
        
        消费者丢失：自动确认模式修改位手动确认模式
24. **数据库隔离级别**
    
    1.  ****
        
        读未提交:会产生脏读，不可重复读，幻读
        
        读已提交：避免脏读
        
        可重复读（mysql）避免脏读和不可重复读
        
        序列化
25. **Mybatis\#\{\}****和****\{\}****有什么区别，需求一定要使用****\{\}****怎么防止****sql****注入**
    
    1.  ****
        
        \#\{\}是占位符，\{\}是拼接符
        
        可以使用正则表达式校验传入参数
        
        或者使用字符串过滤参数
26. **spring** 
    
    1.  bean的生命周期
        
         *  实例化
            
            1.  在堆中开辟空间，对象属性都是默认值
         *  初始化
            
            1.  填充属性（populateBean）
         *  创建对象可以分为getBean-doGetBean-createBean-doCreateBean-
         *  销毁
    2.  怎么解决循环依赖
        
         *  假如两个bean相互依赖，bean在创建的过程中分为实例化和初始化，初始化赋值时会发现容器中没有依赖对象，那么就会循环的执行创建对象过程
         *  使用三级缓存解决循环依赖
            
            1.  利用缓存概念，当我们在赋值从容器中寻找bean，换成从缓存中获取bean，那么就不会循环依赖
            2.  一级缓存存储的是赋值后的bean
            3.  二级缓存存储的是实例化未赋值的bean
            4.  三级缓存（为了解决aop过程中存在动态代理的时候）
                
                1.  存储了一个回调方法，作用是返回一个唯一对象
                2.  在getEarlyBeanReference中可能会将普通对象替换成代理对象
                3.  在容器中同名对象仅有一个，在访问时普通对象和代理对象不能同时对外暴露
27. **BigDecimal**
    
    1.  需要高精度超过16位的数据运算
28. **Mysql****中****INNER JOIN****和****LEFT JOIN****的区别**
    
    1.  取交集 
    2.  取全集但是是以左边为准
29. **lock****和****Synchronized** **区别，什么是****AQS**
    
    1.  lock是类，可以公平和非公平，可中断的，必须手动释放锁，底层实现是volatile和CAS实现的，Sychronized关键字，非公平，不可中断。
    2.  队列同步器，是并法包的基础组件内部使用一个volatile标识的state代表加锁状态，加锁线程标量，等待队列(双向队列，若发现状态位使用，那么会监听上一个队列)
30. 常用java队列底层实现原理
    
    1.  PriorityBlockingQueue 基于二叉堆实现的，结构类似于完全的二叉树
        
         *  理解为叶子节点永远比节点小或者大，适合查询最大或者最小查询，查询的时间复杂度为O(1)，同样常用于优先级查询中
31. MYSQL B+树查询快速的核心
    
    1.  核心是层数只有1-3层，查询的时间次数只有1-3次
    2.  Mysql最小存储单位是页，1-3层换算下来的存储量大概再千万级别，基本够用了
32. Cas,ABA问题
    
    1.  CAS其实主要是调用本地方法，利用CPU的CAS指令，借助JNI来完成的，所以是高效原子操作
    2.  包含三个操作数，内存位置，预期值和新值
    3.  若内存位置和预期值匹配，那么CAS就会更新值
    4.  但是存在ABA问题：
        
         *  如果有个值原来是A，但是中途变成了B，后面又变成了A,那么对应CAS来说是未改变的。
         *  最简单的方式是在更新的时候设置版本号或者Java已经提供了方法compareAndSet会预先检查当前引用是否等于预期引用
33. 从内存模型来说，为什么hashmap会出现值覆盖
    
    1.  在内存模型中规定所有的变量存储在主内存中，线程有单独的工作内存，操作是在工作内存中，操作完毕后在拷贝回主内存，所以会出现值覆盖问题
34. Redis的底层实现原理和时间复杂度
    
    1.  List: 底层是ziplist和quickList(内部使用了双向链表，同时也使用了zipList)
    2.  Hash: zipmap(类似于经量级的hashmap)和dict(链表结构)
    3.  Set：使用的是intset(类似于数组)和hashtable
    4.  Zset：
        
         *  底层实现其一是跳跃表，时间复杂度从O(N)->O(logN)
         *  跳跃表：若查询链表时间复杂度就是O(N)，若在链表之上添加多层索引，那么查询的时候每多加一层那么查询效率就会提升，是一种空间换时间的查询结构
35. Mysql 不走索引的情况
    
    1.  In(两个参数以上)
    2.  Like(%aa和%aaa%)
    3.  条件中有表达式
    4.  Where条件中有不等于
    5.  Exists 和not exists 外层都会全表扫描内层都会走索引
36. 网络通信
    
    1.  BIO,NIO,AIO
        
         *  同步阻塞
         *  同步非阻塞
            
            1.  面向缓冲区的，经常使用的ByteBuffer缓冲
         *  异步非阻塞
    2.  Netty执行流程
        
         *  服务启动选择NioEventLoop对指定的端口进行监听
         *  客户端启动选择NioEventLoop来连接，并创建Channel，服务端收到后选择一个NioEventLoop来和Channel绑定
         *  客户端通过Channel发送数据包，服务端Pipeline对数据进行处理
         *  若服务端需要返回消息，则通过Pipeline将数据处理成ByteBuf，通过Channel传输
    3.  底层实现
        
         *  NioEventLoop和NioEventLoopGroup本身就是一个线程池线程Executer，并且都在内部也实现了一个新的Executer
         *   
37. 什么是StampedLock
    
    1.  是一种乐观锁策略，在性能上是重入锁和读写锁的几倍
    2.  不可重入，不支持wait/notify机制
    3.  底层数据结构
        
         *  由一个链表的队列实现
38. 什么是spring 容器
    
    1.  FactoryBean和BeanFactory
        
         *  BeanFactory是负责生产和管理bean
         *  FactoryBean只是一个接口，只是一个bean，是一个能够生产或者修饰对象的工厂bean
    2.  就是存储bean的容器，根源上来说BeanFactory就是最初始的容器，但是能够独立容器的还是DefaultListableBeanFactory，将整个bean的生命周期都在容器中完成
39. linux命令
    
    1.  查找文件：find,locate(find -name的另外一种写法，快速查找)
    2.  查找字符串：grep
    3.  查看系统配置
        
         *  Cpu cat /proc/cpuinfo
         *  内存 cat /proc/meminfo
         *  磁盘 fdisk -l | grep Disk
         *  线程数
40. Sleep,wait/notify,notifyall,Synchronized 内部使用wait/notify会不会死锁
    
    1.  Wait会释放锁
    2.  Sleep会使得线程阻塞
    3.  Notifyall 会唤醒所有线程，让他们去竞争锁
    4.  为什么wait方法需要再Synchronized 方法里面使用
        
         *  并发情况下wait方法可能或错过唤醒从而进入死锁
         *  例如经典的生产消费，并发下，消费者发现队列是空希望进入等待，同时生产者放入消息，执行Notify 此时并没有等待线程，唤醒失败，那么消费者继续进行无限等待
41. 消息队列怎么保证消费幂等性
    
    1.  若该数据是要写库，那么先根据主键查询一下，若存在了就更新
    2.  若是存储在redis，那么每次都是set，天然的幂等性
    3.  其他情况，在消息上添加一个唯一键，缓存在redis中，消费者消费时先去redis查是否消费过了
42. Spring security和shiro的区别
    
    1.  Security是重量级shiro是轻量级
    2.  security依赖于spring 容器，shiro不需要依赖于任何框架，且简单灵活
    3.  Security功能更加丰富，例如安全维护
43. 红黑树和B+树的区别
    
    1.  红黑树常用于内存，数据量过大，红黑树出现树深度增加而造成磁盘io过于频繁
    2.  B+常用于磁盘，因为它最小单位是页，一个父节点只有两个子节点，并不能完全填满页，B+树一个节点可以有多个子节点，这样可以将页单位装满，深度更浅，那么IO次数越少
44. Spring怎么解决构造方法循环引用问题
    
    1.  Spring 没有直接解决构造器 下注入循环依赖问题
    2.  提供了相关机制来解决，在构造函数中使用@Lazy
        
         *  原理是扫描到这个注解后，赋值的对象是注入对象的代理对象，这样对象就完整了，不会出现循环依赖问题
         *  当我们要调用真实对象时通过TargetSource取获取到真实对象，利用反射区完成调用
45. Mysql 为什么选择b+树，Redis为什么选择跳跃表
    
    1.  首先从实现复杂度来说跳跃表实现简单
    2.  使用场景不同：B+树利用叶子节点存储索引，非叶子节点存储数据，将节点设置为磁盘页大小，充分利用磁盘预读功能，减少磁盘IO。而Redis不涉及IO操作，范围查找上跳跃表更简单
46. Spring boot 自动装配怎么实现的
    
    1.  自动装配就是例如我们想用一个redis 只需要引入redis的starter就可以
    2.  通过我们使用的@SpringBootApplication复合注解实现的，其中有enableautoConfiguration
    3.  通过springFactorysLoader    最终加载指定路径的spring.factories 配置文件中所有的类进行加载通过名称进行绑定关系
47. Spring boot怎么启动的
    
    1.  首先从main方法开始，到达ConfigurableApplicationContext 方法中，该方法主要做的事（配置属性，获取到监听器，初始化相关参数和环境，创建上下文，处理上下文，最后发布已启动事件）
    2.  tomcat中会根据WEB类型（响应式web和非web）来实例化指定的类
    3.  tomcat的启动是在刷新上下文中，主要初始化连接器和容器
    4.  一个tomcat 就是一个Sever 又包含多个service -->包含着多个连接器和容器-->存在子容器
48. Spring aop怎么实现的
    
    1.  使用代理模式实现的
49. Rabbitmq实现原理
50. jvm 堆栈，区别，线程共享还是线程私有的
    
    1.  堆主要时放对象，栈主要是引用数据和基本数据类型
    2.  堆是线程共享，栈式私有的
51. mybatis一对多，多对多怎么做
    
    1.  一对多和多对多再xml中result 中定义collection标签
    2.  多对一定义asscoiation标签
52. mysql有一条数据死锁了，怎么排查问题，mysql表死锁，怎么排查
    
    1.  首先查看死锁日志，找到产生死锁的几个事务
53. mysql导入大量数据怎么优化
    
    1.  Insert 语句合并数据（value 值多个）
        
         *  合并后，日志量减少降低日志刷盘次数
    2.  再一个事务中进行插入
54. jvm参数调优怎么做的
    
    1.  \-Xms 初始堆大小
    2.  \-Xmx 最大堆大小
    3.  \-XX:NewSize 设置年轻代大小
    4.  选择垃圾回收器
55. mysql优化
    
    1.  数据库设计：
        
         *  优先选择小的类型字段
         *  尽可能将字段全部设定为不为空（会需要更大的存储空间，因为涉及到判Null需要额外的标识符）
    2.  sql优化
        
         *  避免类型隐式转换
         *  用in代替or
         *  Where 不要添加函数计算
56. java的序列化和反序列化什么含义 生成的serialVersionUID有什么用
    
    1.  作为存储
    2.  在网络中传输字节序列
    3.  用于判断版本是否一致，jvm反序列化时会将版本做比对
57. Java 基础
    
    1.  == 比较的是对象equals 比较的是值
    2.  直接赋值会先去常量池里面找，new String会直接分配对象，再去常量池查找，若没有则创建，然后建立联系
    3.  方法重写（同一个类，方法名相同，参数不同，和修饰符返回类型无关）
    4.  方法覆盖（方法名相同，返回值必须是同父类或者子类，修饰符权限必须大于等于父类，异常必须是相同或者不抛出异常）
    5.   
    6.   
58. http和https的区别，tcp 3次握手和4次挥手
    
    1.  https需要颁发证书，http是超文本传输协议，https是ssl加密传输协议，使用的连接方式也不同，http使用的80 https使用的443
    2.   Tcp是双工传输 三次握手
        
         *  首先客户端发送syn同步包，客户端处于syn\_sent
         *  服务端收到后会发送syn同步包和ack回应消息 服务端处于syn\_rcvd
         *  客户端回应ack，此时可以携带数据。三次握手是为了建立双向连接
         *  为什么需要三次握手
            
            1.  因为网络原因产生的失效消息，会让服务端误以为是要建立连接发送ack确认，但是一直等不到客户端回消息，直到到达等待时间才关闭连接，造成资源浪费
            2.  Syn攻击，利用网络伪造攻击报文，造成半开连接队列满了，通过不回应服务端的syn+ack，使得服务端资源巨大消耗
    3.  四次挥手
        
         *  首先客户端发送FIN报文，附带序列号停止发送数据关闭tcp连接`FIN_WAIT1` 状态
         *  服务端收到FIN后返回ACK确认消息 `CLOSE_WAIT` 状态
         *  若服务端也想断开连接，同样发送FIN `LAST_ACK` 状态
         *  客户端收到后，一样发送ACK确认`TIME_WAIT` 等待一定时间后进入关闭状态
         *  为什么需要四次挥手
            
            1.  若只有3次挥手，客户端发送数据请求断开连接，次数服务端数据可能未发送完毕数据此时断开可能数据损失，
59. 怎么创建索引
    
    1.  Create Index
60. String final修饰的
    
    1.  为了实现字符串池 当共享字符串改变的话那么所有的引用也会改变
    2.  线程安全的
    3.  可以创建HashCode不可变性 在创建HashCode被缓存不需要再次计算
61. String字符串
    
    1.  String 是使用char类型的数组存储的
    2.  源码中length方法返回对象是int 0-65565 虚拟机需要一个字符作为结束，所有在编译期是0-65564，若是在运行期进行字符串拼接可以超出这个范围
62. 集合原理
    
    1.  ArrayList
        
         *  默认大小的数组 如果大小超过了自动扩容1.5倍
    2.  LinkedList
        
         *  双向链表 新增为链表尾部，删除替换链表前后节点
    3.  HashMap
        
         *  内部是数组 每隔数组下面是一个单向链表
         *  拥有负载因子 达到临界值自动扩容2倍
         *  使用的时候key必须重写了hasCode和equal
         *  Java8 优化：链表长度大于8的时候会替换成红黑树（由平衡二叉树）
    4.  hashMap hash实现
        
         *  通过key 的hashCode高16位做异或运算 这样做是减少key 的冲突
    5.  hashmap如何确定在table的位置
        
         *  采用了效率更高的位运算 确定位置，使用位运算的前提就是数组table的长度必须是2的指数幂
    6.  hash碰撞
        
         *  两个对象的key的hashCode是一样的时候
         *  hashmap采用链地址法来解决
    7.  LinkedHashMap
        
         *  双向链表加HashMap实现
    8.  TreeMap
        
         *  红黑树实现
    9.  HashSet
        
         *  基于HashMap实现
    10. TreeSet
        
         *  底层是TreeMap
    11. LinkedHashSet
63. Class.forName 和ClassLoader区别
    
    1.  所以Class.forName加载类是将类进了初始化，而ClassLoader的loadClass并没有对类进行初始化，只是把类加载到了虚拟机中
    2.  都是双亲委派原则，先让父加载器加载，最终调用启动类加载器的类加载器
64. session和cookie的区别 session生命周期 多服务session管理
    
    1.  保存在服务端和客户端
    2.  第一次访问创建，服务端自动销毁
    3.  使用jwt无状态管理，使用中间件redis统一管理
65. Java中的队列
    
    1.  ArrayBlockingQueue：基于数组结构的有界阻塞队列，规定大小的BlockingQueue，其构造函数必须带一个int参数来指明其大小。 其所含的对象是以FIFO(先入先出)顺序排序的
    2.  PriorityBlockingQueue：具有优先级的无限阻塞队列，类似于LinkedBlockingQueue,但其所含对象的排序不是FIFO，而是依据对象的自然排序顺序或者是构造函数所带的Comparator决定的顺序1
    3.  SynchronousQueue：不存储元素的阻塞队列，对其的操作必须是放和取交替完成的，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue
    4.  LinkedBlockingQueue和ArrayBlockingQueue比较起来，它们背后所用的数据结构不一样，导致LinkedBlockingQueue的数据吞吐量要大于ArrayBlockingQueue，但在线程数量很大时其性能的可预见性低于ArrayBlockingQueue
    5.  对比 ：
        
        1.  **ArrayBlockingQueue性能优于LinkedBlockingQueue,但是LinkedBlockingQueue是无界的。**
        2.  **ArrayBlockingQueue和LinkedBlockingQueue的poll方法总是比offer方法快，并发越高，差距越大**
        3.  **ArrayBlockingQueue和LinkedBlockingQueue的性能远高于PriorityBlockingQueue，显然优先队列在比较优先级上的操作上耗费太多**
        4.  **PriorityBlockingQueue的offer方法与poll方法的性能差距很小，基本维持在近似1：1**
    6.  非阻塞队列：
        
        1.  ConcurrentLinkedQueue
        2.  PriorityQueue
66. Java 内存模型和GC算法
    
    1.  内存模型
        
         *  方法区 （线程共享区域存储类，常量，静态变量，即时编译代码）
         *  堆 （存储对象）
         *  虚拟机栈（方法的栈针，调用过程对应着入栈到出战）
         *  本地方法栈（为Native方法服务）
         *  程序计数器
    2.  GC算法：
        
         *  标记清除算法
            
            1.  引用计数算法和可达性分析
            2.  容易产生内存碎片，当需要一个大对象时，不得不进行一次GC FULL
         *  复制算法
            
            1.  将内存分为两块
            2.  碎片少，但是空间利用低下
         *  标记整理算法
            
            1.  标记对象，将存活对象向一边移动，留下较大的连续内 存
67. 垃圾回收器
    
    1.  Serial收集器（复制算法)
        
         *  单线程收集器，垃圾收集时stop the world
    2.  ParNew收集器(复制算法)
        
         *  多线程Serial 目前是仅有的可以喝CMS（老年代）配合使用
    3.  Parallel Scavenge收集器(复制算法)
        
         *  新生代多线程收集器 达到可控的吞吐量
    4.  Serial Old收集器(标记-整理算法)
        
         *  老年代收集器
    5.  Parallel Old收集器(标记-整理算法)
        
         *  多线程Parallel Scavenge老年代收集器
    6.  CMS收集器（标记-清除算法）
        
         *  最短回收停顿时间
         *  初始标记》并发标记》重新标记》并发清除
         *  对cpu资源敏感，无法处理在运行和清理进行时产生的浮动垃圾当内存不够时将启用Serial Old后备预案
         *  标记清除算法，产生碎片导致
    7.  G1收集器
        
         *  标记整理+复制算法 不会产生大量碎片
         *  分代收集器 区分年轻代和老年代
         *  将堆分成多个区域 采用不同的方式收集不同的区域 会评估区域价值，设定优先回收区域，避免了全局扫描提高回收效率
         *  停顿时间是可控的
    8.  spring mvc流程和原理
        
         *  流程：
            
             *  用户发送请求至前端控制器DispatcherServlet。
             *  DispatcherServlet收到请求调用HandlerMapping处理器映射器。
             *  处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
             *  DispatcherServlet调用HandlerAdapter处理器适配器。
             *  HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
             *  Controller执行完成返回ModelAndView。
             *  HandlerAdapter将Controller执行结果ModelAndView返回给DispatcherServlet。
             *  DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
             *  ViewReslover解析后返回具体View。
             *  DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。
             *  DispatcherServlet响应用户
    9.  Spring 事务隔离级别和传播行为
        
         *  事务隔离级别
            
             *  READ UNCOMMITTED（读未提交数据）：允许事务读取未被其他事务提交的变更数据，会出现脏读、不可重复读和幻读问题。
             *  READ COMMITTED（读已提交数据）：只允许事务读取已经被其他事务提交的变更数据，可避免脏读，仍会出现不可重复读和幻读问题。
             *  REPEATABLE READ（可重复读）：确保事务可以多次从一个字段中读取相同的值，在此事务持续期间，禁止其他事务对此字段的更新，可以避免脏读和不可重复读，仍会出现幻读问题。
             *  SERIALIZABLE（序列化）：确保事务可以从一个表中读取相同的行，在这个事务持续期间，禁止其他事务对该表执行插入、更新和删除操作，可避免所有并发问题，但性能非常低。
         *  传播行为
            
             *  PROPAGATION\_REQUIRED–支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
             *  PROPAGATION\_SUPPORTS–支持当前事务，如果当前没有事务，就以非事务方式执行。
             *  PROPAGATION\_MANDATORY–支持当前事务，如果当前没有事务，就抛出异常。
             *  PROPAGATION\_REQUIRES\_NEW–新建事务，如果当前存在事务，把当前事务挂起。
             *  PROPAGATION\_NOT\_SUPPORTED–以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
             *  PROPAGATION\_NEVER–以非事务方式执行，如果当前存在事务，则抛出异常。
         *  默认隔离级别
            
             *  mysql:**REPEATABLE READ** 可重复读
             *  oracle:**READ COMMITTED** 读已提交数据
         *  为什么mysql没有出现幻读
            
             *  InnoDB主要是利用锁来解决幻读问题
                
                 *  InnoDB的锁主要分为（Record Lock：单个行记录上的锁）（Gap Lock：间隙锁，锁定一个范围，而非记录本身，遵循左开右闭原则）（Next-Key Lock：结合Gap Lock和Record Lock，锁定一个范围，并且锁定记录本身。主要解决的问题是REPEATABLE READ隔离级别下的幻读。）
    10. Spring IOC和AOP实现原理
        
         *  IOC:控制反转，就是把对象的创建交给Spring来做
         *  AOP底层实现原理：动态代理
    11. 怎么实现动态代理
        
         *  首先需要一个接口，有一个InvocationHandler的处理类（将接口类对象传给它），还需要一个代理类（调用它的newInstance产生一个代理对象），利用InvocationHandler拼接代理类源码，编译成二进制，再使用加载器产生代理对象
    12. ReentrantLock 和 synchronized 区别和实现原理
        
         *  synchronized
            
             *  Java对象头+Monitor(内部锁)，在1.6之前需要从用户状态切换到核心状态，1.6之后引入多种优化
         *  ReentrantLock
            
             *  重入锁 特点：等待可中断，实现公平锁，锁可以绑定多个条件
         *  **synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API**
            
             *  **在1.6中jvm对于synchronized 实现了大量的优化，性能上有显著提升**
             *  **实现原理：**
                
                 *  **修饰代码块-->通过一个监视器锁**monitor完成的。当monitor被占用时数值设置为1，进入阻塞状态，monitorenter 和monitorexit 其中会使用两个monitorexit  在异常情况下的退出，防止死锁
                 *  修饰方法-->设置方法标志**ACC\_SYNCHRONIZED** 实现了重入，底层维护了一个计数器，当计数器为0时则表示可以竞争锁
                 *  锁优化：
                    
                     *  偏向锁 当锁不存在竞争，将锁偏向于该线程提升效率
                     *  轻量级锁 多线程不会再同一时刻竞争同一把锁
                     *  重量级锁 多线程竞争同一把锁
                     *  自旋锁 线程未获得锁会自旋的不断重新获取锁，
                     *  自适应自旋锁 会根据上一次自旋次数自适应的重复获取锁
                     *  锁消除 线程私有变量，没有并发问题会自动去掉
                     *  锁粗化 循环中存在锁的行为，会将锁提到循环外执行，减少锁的使用提升性能
    13. atomicinteger原理和作用
        
         *  内部是使用volatile 修饰，防止指令重排，和可见性
         *  CAS是乐观锁的一种实现方式，利用CPU自身特性保证原子性，避免类似悲观锁的线程切换，性能较强
    14. 分布式锁的实现方式
        
         *  基于数据库实现分布式锁； 
            
             *  利用数据库对字段的唯一性约束，达到多个请求时只有一个成功
             *  缺点：
                
                 *  非阻塞，占用则后面进入则报错
                 *  数据库为单点，挂了之后影响业务
                 *  无法重入，当前线程获取之后无法再次获取
         *  基于缓存（Redis等）实现分布式锁； 
            
             *  在主从结构中会出现竞争情况
         *  基于Zookeeper实现分布式锁；
            
             *  存储结构类似于树状，分为多个节点（持久节点，持久节点顺序节点，临时节点，临时节点顺序节点）
             *  实现原理：
                
                 *  创建一个持久节点，当线程获取锁时，在该节点下创建临时顺序节点，之后该线程检查临时顺序节点排序判断是否是第一个节点，是则获取锁。
                 *  当第二个线程获取时，判断顺序不是最小的，会去监听上一个线程节点，进入等待状态
    15. 异步非阻塞
    16. tomcat在spring boot中怎么启动的
        
         *  首先从main方法开始，到达ConfigurableApplicationContext 方法中，该方法主要做的事（配置属性，获取到监听器，初始化相关参数和环境，创建上下文，处理上下文，最后发布已启动事件）
            
             *  tomcat中会根据WEB类型（响应式web和非web）来实例化指定的类
             *  tomcat的启动是在刷新上下文中，主要初始化连接器和容器
             *  一个tomcat 就是一个Sever 又包含多个service -->包含着多个连接器和容器-->存在子容器
    17. tomcat 的连接器和容器作用
        
         *  连接器 主要对外交流 处理socket连接，网络字节流与 Request 和 Response 对象的转化
         *  .加载和管理 Servlet，以及具体处理 Request 请求。
    18. spring sercurity 原理
        
         *  使用的是责任链的设计模式，有一条很长的过滤链
         *  当请求来时，经过过滤链到达LogoutFilter 判断路径，到达对应的handler 
         *  当到UsernamePasswordAuthenticationFilter 判断路径，到达指定的处理器处理
         *  到达FilterSecurityInterceptor 时则会获取到url去对应的鉴权处理器处理
         *  UserDetails（如果需要自定义用户类需要实现接口）
         *  GrantedAuthority（自定义权限） 
         *  UserDetailsService（自定义用户服务类，登录是会调用loadUserByUsername）
         *  完成登录后，会将用户信息存储在SecurityContextHolder 实际原理是使用ThreadLocal存储
         *  \---
            
            ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIzOTQ1Njg1_size_16_color_FFFFFF_t_70][]
            
             
         *  请求来被过滤链中的UsernamePasswordAuthenticationFilter拦截将用户名和密码封装成UsernamePasswordAuthenticationToken对象
         *  过滤器将UsernamePasswordAuthenticationToken提交给认证管理器AuthenticationManager
         *  AuthenticationManager管理器委托AuthenticationProvider进行认证
         *  AuthenticationProvider授权提供者调用UserDetailsService获取到用户信息，然后指派密码编码器进行比较
         *  授权提供者认证成功后返回授权对象Authentication（包含用户名，密码，权限）
         *  授权对象Authentication返回到UsernamePasswordAuthenticationFilter，通过SecurityContextHolder工具存储
         *  最后SecurityContextPersistenceFilter通过SecurityContextHolder.getContext()获取到SecurityContext对象，调用SecurityContextRepository将SecurityContext存储，，然后清理掉SecurityContext
         *  在认证流程中，一般来说只用自定义UserDetailsService，该方法是需要在数据库中验证用户相关信息
    19. activity流程
        
         *   
    20. Spring cloud Security Oauth2
        
         *  流程：
            
             *  用户发起token请求
             *  过滤器验证是否是认证请求，如不是直接返回
             *  过滤器根据clientId生成鉴权对象
             *  通过username和鉴权对象生成UserDetails，检查用户是否存在
             *  以上通过后会进入/oauth/token 到达postAccessToken方法中
             *  postAccessToken验证作用域和请求方法
             *  之后调用AbstractTokenGranter grant 到达AbstractUserDetailsAuthenticationProvider 到达对应实现类**通过username和Authentication对象来检索用户是否存在**
             *  然后通过DefaultTokenServices类**从tokenStore中获取OAuth2AccessToken对象**。
             *  最后将Oauth2AccessTOken对象包装返回
    21. 锁volatile和synchronize特点区别和实现原理
        
         *  volatile 轻量级同步
            
             *  （可见性）
                
                 *  当值发生改变，会立即同步到主内存，对于其他线程来说是立即得知的
                 *  但是可见性不意味着线程安全的，在同步到内存中的过程中read load中如果值发生改变那么获取到的就是过期数据
             *  （防止指令重排）
                
                 *  实现原理：实现了一种内存屏障 来防止指令重排
         *  synchronize 
            
             *  作用于字段会生成同步块，在同步块前后插入指令，该指令只能单一持有，只有当释放持有时，其他线程才能持有
             *  作用于方法时，会在给方法设置标识符，若存在值则想去获取同步块指令
    22. jvm 内存模型
        
         *  方法区：存储虚拟机加载的类信息，常量，静态常量，及时编译后的数据，无法扩展时OutOfMemoryError
         *  虚拟机栈：线程私有，每一个方法会创建栈帧，方法的执行就是入栈和出栈的过程 ，无法扩展时OutOfMemoryError
         *  本地方法栈：为Native方法服务的 (存在StackOverflowError和OutOfMemoryError)
         *  堆：主要为对象，当内存无法扩展时OutOfMemoryError
         *  程序计数器：用作于下一条执行的字节码指令，循环，分支等计数
    23. 对象的创建和销毁
        
         *  创建：
            
             *  遇到new 时先去常量池找是否有符号引用，检查该符号引用被加载和解析初始化，检查完后如果没有那么就会为对象分配内存
             *  假设内存都是绝对规整的，用过的在一边，空闲的在一边，那么分配对象仅仅是指针移动，这种方式为指针碰撞
             *  如果内存不规整，那么虚拟机将维护一张空闲列表，这种方式为空闲列表
         *  访问：
            
             *  用过栈上的reference操作具体对象
                
                 *  句柄访问（划分内存设置句柄池）
                 *  指针访问 访问速度快 sun hotspot使用的这种
         *  销毁：
            
             *  引用计数法 给对象添加引用计数器，存在相互引用循环问题
             *  可达性分析 创建GC roots 根节点的引用链
             *  当可达性分析发现没有引用后会标记筛选 finalize()将是对象最后机会避免清除的方法
         *  分配规则
            
             *  对象优先分配Eden区 若空间不足触发Minor GC
             *  大对象直接进入老年代 避免内存拷贝，新生代是复制算法
             *  长期存活对象进入老年代
             *  空间分配担保
    24. jvm调优工具
        
         *  调优命令
            
             *  jps，JVM Process Status Tool,显示指定系统内所有的HotSpot虚拟机进程。
             *  jstat，JVM statistics Monitoring是用于监视虚拟机运行时状态信息的命令，它可以显示出虚拟机进程中的类装载、内存、垃圾收集、JIT编译等运行数据。
             *  jmap，JVM Memory Map命令用于生成heap dump文件
             *  jhat，JVM Heap Analysis Tool命令是与jmap搭配使用，用来分析jmap生成的dump，jhat内置了一个微型的HTTP/HTML服务器，生成dump的分析结果后，可以在浏览器中查看
             *  jstack，用于生成java虚拟机当前时刻的线程快照。
             *  jinfo，JVM Configuration info 这个命令作用是实时查看和调整虚拟机运行参数。
         *  调优工具
            
             *  jconsole，Java Monitoring and Management Console是从java5开始，在JDK中自带的java监控和管理控制台，用于对JVM中内存，线程和类等的监控
             *  jvisualvm，jdk自带全能工具，可以分析内存快照、线程快照；监控内存变化、GC变化等。
             *  MAT，Memory Analyzer Tool，一个基于Eclipse的内存分析工具，是一个快速、功能丰富的Java heap分析工具，它可以帮助我们查找内存泄漏和减少内存消耗
             *  GChisto，一款专业分析gc日志的工具
    25. JVM性能调优
        
         *  设定堆内存大小
         *  \-Xmx：堆内存最大限制。
         *  设定新生代大小。 新生代不宜太小，否则会有大量对象涌入老年代
         *  \-XX:NewSize：新生代大小
            
            \-XX:NewRatio  新生代和老生代占比
            
            \-XX:SurvivorRatio：伊甸园空间和幸存者空间的占比
         *  设定垃圾回收器 年轻代用  -XX:+UseParNewGC  年老代用-XX:+UseConcMarkSweepGC
    26. Minor GC 和 Full GC
        
         *  新生代内存不足发生Minor GC
         *  JVM内存不足发生Full GC
    27. 永久代GC
        
         *  永久代超过临界值会触发Full GC
    28. 类的生命周期
        
         *  加载
         *  连接 （包括验证，准备，初始化）
            
             *  验证，文件格式、元数据、字节码、符号引用验证；
             *  准备，为类的静态变量分配内存，并将其初始化为默认值；
             *  解析，把类中的符号引用转换为直接引用
         *  初始化
         *  使用
         *  卸载
    29. 类加载器
        
         *  双亲委派模型
            
             *  类加载器收到加载请求不会自己尝试加载，而是委派父类加载器完成，层层递上，最后都无法加载才会让该类加载器加载，避免同名对象加载混乱
    30. 首先HashMap是**线程不安全**的和hash碰撞
        
         *  在jdk1.7中，在多线程环境下，扩容时会造成环形链或数据丢失
         *  在jdk1.8中，在多线程环境下，会发生数据覆盖
    31. ## ConcurrentHashMap ##
        
         *  线程不安全的hashmap,效率低下的hashtable（使用synchronized作为整个对象的锁，多线程出现高并发竞争同一个锁）
         *  concurrenthashmap 使用的是分段锁，每一个数据都是有单独的一把锁
         *  在jdk1.7中使用的是Segment数组结构和HashEntry数组结构组成 其中segment使用的是可重入锁ReentrantLock，是一种数组（Segment） + 数组（HashEntry） + 链表（HashEntry节点）
         *  在1.8中使用Node替换原有结构，是一种链表结构。使用的是优化的synchronized 关键字同步代码块 和 cas操作了维护并发。使用 Node数组+链表+ 红黑树
         *  TreeNode是节点，当节点大于8时由原来的二叉树结构更换成红黑树结构
         *  1.7ConcurrentHashMap 使用的分段锁，如果一个线程占用一段，别的线程可以操作别的部分，  
            1.8简化结构，put和get不用二次哈希，一把锁只锁住一个链表或者一棵树，并发效率更加提升。
    32. 序列化和反序列化实现原理
        
         *  序列化：将java对象转换成字节序列
         *  反序列化：将字节序列转换成java对象
         *  序列化步骤：
            
             *  将对象实例相关的类元素输出
             *  递归找到类的超类
             *  完成类元素输出后，从顶层开始输出元素实际值
    33. 接口保证幂等性是基本的要求，那么幂等性你们是怎么做的
        
         *  幂等就是一个操作，不论执行多少次，产生的效果和返回的结果都是一样的
         *  方案：
            
             *  查询，删除都是天然的幂等
             *  唯一索引防止新增的脏数据（当并发新增的时候报错，重新查询一次，若存在则正常返回）
             *  token机制 接口被重复调用，则可以使用token+redis 或者内存 数据提交申请token 设置过期时间
             *  悲观锁
             *  乐观锁 通过版本号或者状态 只在更新数据那一刻才会锁表
             *  分布式锁
         *  接口对外是保证幂等 ：在调用接口时提供来源和来源的序列号这两个字段在数据库中做联合唯一索引，第三方调用时首先查询该业务是否已经处理过
    34. 你们有用@Transactional来控制事务是吧，那么能不能说出一些事务不生效的场景
        
         *  数据库不支持事务 例如myisam
         *  注解类是否被实例化成bean
         *  方法是否是public
         *  是否有自我调用
         *  数据源是否加载了事务管理器
    35. 序列化
        
         *  将java对象转换成字节序列的过程
         *  用途可以让对象保存在硬盘上，减少内存压力，序列化后可以在网络中传输
         *  序列化相当于关键字的作用，在序列化的时候会判断对象是属于什么类型，若是序列化则执行相应的操作
         *  serialVersionUID是反序列化是验证版本ID的
    36. NIO原理
        
         *  非阻塞的
         *  NIO是以块的方式处理数据，但是IO是以最基础的字节流的形式去写入和读出的。所以在效率上的话，肯定是NIO效率比IO效率会高出很多
         *  采用的是通道缓冲区的模式 主要是利用缓冲区来进行数据传输
    37. redis 内存耗尽
        
         *  redis服务中key值设置有效期，防止一直占用内存
         *  假如所有的key值都没有过期，内存满了过后，redis提供了8种淘汰策略
            
             *  根据LRU算法删除过期的key
             *  根据LRU算法删除所有的key
             *  根据LFU算法删除过期的key
             *  根据LFU算法删除所有的key
             *  随机删除过期的key
             *  随机删除所有的key
             *  根据对象的TTL属性，删除即将临期的
             *  默认策略，内存耗尽直接报错
         *  LR算法：
            
             *  redis并没有使用传统的LRU算法（需要额外的空间存储，存在热点key，但是最近没有使用而被删除）
             *  redis改进了LRU算法，进行抽样删除，配置文件可设置抽样数量
             *  redis是如何管理热点数据
                
                 *  在redisObject中，存在一个1ru属性记录对象最后一次被程序访问的时间
                 *  在redis中维护了一个全局属性，该属性通过定时任务周期性更新当前时间戳（没有直接获取当前系统时间戳的原因是提高更新的效率）
                 *  该方式存在1ru仅有24位，最多存储194天的时间戳，所以删除只是算法的近似值
             *  LFU算法
                
                 *  最近少频率使用的，同样使用redisObject的1ru属性，高16位来访记录时间，低8位为访问频率
                 *  采用逐级递减访问频率，来防止存储值到达255最大值
    38. mysql的索引原理和数据结构
        
         *  mysql 采用的是Hash索引和B+树索引
         *  InnoDB采用的是B+树索引
            
             *  N棵子Tree的节点包含N个关键字，不保存数据保存的是数据的索引
             *  所有的叶子节点中包含了全部的关键字信息，以及关键信息的记录指针，且叶子根据关键字的大小顺序连接
             *  所有的非终端节点可以看作索引的一部分，节点中仅包含子树最大或者最小的关键字
             *  B+树中，数据的插入和删除仅在叶节点上进行
                
                 *  B+树有两个指针头，一个是树的根节点，一个是最小关键码的叶节点
         *  索引算法分为hash算法和BTree算法
            
             *  BTree算法是mysql默认算法，支持比较符和模糊匹配
             *  Hash算法仅能做对等比较，但是效率很 
    39. B+树和B树的区别
        
         *  在B树中，可以将键和值存放在内部节点和叶子节点，但是B+树中，内部节点都是键，没有值，叶子节点同属存放键和值
         *  B+树的叶子节点有一条链相连，而B树的叶子节点各自独立
         *  B树在内部节点同时存储值和键，优点是将频繁访问的数据放置在靠近根节点处，将大大提高查询效率
         *  B+树存放方式能够快速缩小查询范围
    40. mysql聚簇索引和非聚簇索引的区别
        
         *  聚簇索引：将索引和数据放置在一块，找到了索引即找到了值
         *  将数据和索引分开放置，索引的叶子节点指向了数据，myisam先将索引缓存在内存中，当查询数据时先查索引在查数据，当未命中索引则查询效率低下
    41. 什么是回表、索引覆盖、最左匹配原则、索引下推
        
         *  回表：存在主键索引和普通索引，当查询普通索引时，查询到主键还要通过主键索引再查询一次，从非聚簇索引到聚簇索引就是回表（非聚簇索引也不一定回表，若索引全命中，则不必回表）
         *  索引覆盖：查找的列正好是主键，则不需要去b+树再次查找
         *  最左匹配原则：索引必须是组合索引，两个索引会匹配左边的第一个
         *  索引下推：在数据查询返回服务时，当有多个条件查询，会根据最左原则先匹配到数据，然后找到主键索引依次回表筛选数据，索引下推就是先对包含的字段先做判断，过滤掉不适合的，减少回表次数
    42. mysql索引如何进行优化
        
         *  结构优化
         *  查询优化
    43. 如何实现高并发秒杀系统
    44. 设计模式
        
         *  单例模式
            
             *  懒汉
                
                 *      /**
                             * 线程不安全
                             *
                             * @return
                             */
                        public class Singleton {
                        
                        private static Singleton singleton;
                        
                        private Singleton() {
                        }
                        
                        public static Singleton getInstance() {
                         if (singleton == null) {
                          singleton = new Singleton();
                         }
                         return singleton;
                        }
                        }
                         /**
                             * 线程安全
                             *
                             * @return
                             */
                        public class Singleton {  
                           private static Singleton instance;  
                           private Singleton (){}  
                           public static synchronized Singleton getInstance() {  
                           if (instance == null) {  
                               instance = new Singleton();  
                           }  
                           return instance;  
                           }  
                        }
                    
                     
             *  饿汉
                
                 *      public class Singleton {  
                           private static Singleton instance = new Singleton();  
                           private Singleton (){}  
                           public static Singleton getInstance() {  
                           return instance;  
                           }  
                        }
                    
                     
             *  双重校验锁
             *      public class Singleton {  
                       private volatile static Singleton singleton;  
                       private Singleton (){}  
                       public static Singleton getSingleton() {  
                       if (singleton == null) {  
                           synchronized (Singleton.class) {  
                           if (singleton == null) {  
                               singleton = new Singleton();  
                           }  
                           }  
                       }  
                       return singleton;  
                       }  
                    }
                
                 
    45. 分布式事务
        
         *  2PC
            
             *  是一种协议保证分布系统每一个节点要不都不提交事务，要不都取消事务
             *  引入了一种第三方节点协调者负责通知参与者是否Commit还是回滚
             *  只有两个阶段准备和提交
             *  缺点：同步阻塞，在Commit阶段出现参与者未收到消息导致数据不一致
         *  3PC
            
             *  即是三个阶段提交，将2PC的准备阶段拆分为canCommit和preCommit阶段
             *  引入超时机制来解决同步阻塞
         *  XA
            
             *  是基于2PC的一种规范，基于数据库实现的
         *  本地消息表
            
             *  将分布式事务拆分成本地事务
             *  事务发起者将写业务和发送消息表放在同一个事务中
             *  使用定时轮询将未处理的消息发送的消息中间件
             *  事务被动方从中间件获取消息，处理成功返回，事务发起方更改消息状态
             *  缺点：消息数据和业务耦合，只适用于结果最终一直的业务场景
         *  事务消息
            
             *  本地事务升级版，通过消息中间件来解耦本地消息表和业务数据表，适用于所有对数据最终一致的需求场景（目前只有RocketMQ支持）
             *  发起方发送半事务给消息队列，此时消息状态为准备，接收方还无法获取此消息
             *  发起方执行本地事务
             *  发起方发送确认提交消息给RocketMQ，接收方就可以收到此消息
         *  TCC
            
             *  主要采用的补偿机制，不依赖于数据库
             *  流程和2PC 3PC相似，但是强调补偿，通过业务逻辑来控制确认和补偿
             *  缺点：Confirm和Cancel失败后完全只能靠业务去处理，需要将原接口拆分为三个接口，入侵性大
         *  Saga
            
             *  长时间运行事务，也是一种补偿协议
             *  和TCC相似，但是规范更加宽松，一致性更弱，在第一阶段直接做提交确认，出现问题再做补偿操作，该方式可以拥有一个高吞吐量
         *  Seata
            
             *  高性能简单易用的分布式事务框架
             *  AT模式
                
                 *  基于二段协议实现
             *  TCC模式
             *  Saga模式
    46. Zookeeper
        
         *  分布式协调服务，主要构成为（Leader,Follower,Observer）
         *  常规来说只用Leader可写入，Follower，Observer只负责读，但是Follower会参加节点选举和过半写成功
         *  监听机制：
            
             *  提供分布式数据发布与订阅
             *  客户端向服务端注册监听
             *  保存监听对象到客户端的监听管理器中
             *  服务端监听事件触发过后，客户端收到通知从Manager中获取监听对象，进行回调
         *  如何保证数据一致
            
             *  通过ZAB协议，类似于2PC两端提交过程
             *  Leader收到请求后将它转换成提议，为每一个提议生成全局唯一递增ID,然后将提议放入FIFO的队列中，根据FIFO策略分发给所有Follower
             *  Follower收到提议后，以事务形式存储磁盘，成功后返回ACK确认消息
             *  Leader收到过半的成功ACK消息即认为成功通知Follower 提交提议
             *  ZAB协议：崩溃恢复和消息广播
         *  如何进行选举
            
             *  根据事务ID和自身ID，节点推举自己，根据两个ID判断，过半选择的新Leader则视为选举成功
         *  选举后数据怎么同步的
            
             *  选举成功后Follower和Observer会去向Leader注册，实现数据同步（Observer会去向Leader最后处理事务ID，Leader提议的最大最小事务ID）
             *  根据数值差异进行同步（差异化同步，回滚在差异化同步，仅回滚同步，全量同步）
         *  会出现数据不一致么
            
             *  查询不一致，过半写成功
             *  Leader的提议未发出就**宕机**
             *  Leader的提议发送成功，最后发送Commit**宕机**
    47. 消息中间件
        
         *  RabbitMQ (服务实体，交换机，Queue，绑定键，路由键)
         *  底层实现是根据AMQP高级消息队列协议实现的
         *  简单模式
            
             *  简单收发模式（消费后即删除，若未正常消费会造成消息丢失，可以设置手动ACK）
         *  工作模式
            
             *  资源竞争，高并发下会出现一个资源被多个消费者消费，可以设置同步开关
         *  发布订阅
            
             *  每个消费者只监听自己的队列，有交换机转发到指定队列
         *  路由模式
            
             *  交换机根据路由判断，根据路由键匹配到对应的消息队列上
         *  topic模式
            
             *  类似于路由模式的模糊匹配
         *  如何保证MQ消息顺序
            
             *  拆分多个队列，每一个队列对应一个消费者
             *  在消费者内部使用内存队列排队
         *  消息如何分发
            
             *  循环发送给每一个消费者
         *  消息怎么路由
            
             *  消息有一个路由键，通过路由键将消息绑定在交换器上，交换器根据消息路由键和队列路由键匹配
         *  如何保证消息不被重复消费
            
             *  正常情况消费者消费完后会发送确认消息，由于其他原因导致消费确认送达
             *  在消息上绑定唯一标识，消费时判断下是否消费过
         *  如何保证消息正确发送到MQ，如何保证消息接收方收到了消息
            
             *  发送方确认模式
             *  接收方确认模式
         *  如何保证MQ消息的可靠
            
             *  消息队列丢失消息
                
                 *  开始消息持久化，开启持久化标识
             *  消费者丢失消息
                
                 *  若采用自动确认则会丢失，修改为手动确认
         *  为什么不对所有的消息都持久化
            
             *  会影响吞吐量
         *  如何保证高可用，集群
            
             *  单机模式
             *  普通集群
                
                 *  多台机器多个实例，通过元数据找到对应的队列所在
             *  镜像集群
                
                 *  无论是元数据还是队列数据都会存在在多个实例上
                 *  任何一个机器宕机了都不影响现有业务
         *  若消息队列大量失效，队列满了怎么处理，几百万消息积压几小时
            
             *  先修复消费者的消费速度，建立10倍的队列，建立一个临时消费服务，加速消费
             *  RabbitMQ在大量积压可以设置TTL ，大量积压数据就会大量丢失，等空闲的时候再去回复数据
         *  Kafka会不会丢失消息怎么处理
            
             *  消息丢失会发生在Broker，Producer和Consumer上丢失
             *  Broker
                
                 *  Kafka为提高吞吐量，数据存储的过程中采用批量存储，若系统故障，会丢失数据
                 *  理论上可以缩短刷盘时间间隔，Kafka通过Producer和Broker协同处理这个问题，当Producer发现Broker消息丢失就进行重试
             *  Producer
                
                 *  为提升效率，Kafka会减少IO，将多个请求合并发送
                 *  解决方法异步改为同步，使用阻塞线程池
             *  Consumer
                
                 *  可能会出现Commit后出现异常
                 *  修改自动确认为手动确认
    48. Redis
    49. 零拷贝
        
         *  定义：
            
             *  计算机在执行操作时cpu不需要将数据从某处内存复制到另一个特定区域
             *  可以减少数据拷贝和共享总线操作次数，消除数据传输过程中在存储器之间的不必要拷贝
             *  减少用户地址空间和内核地址空间因为上下文切换带来的开销
         *  原理：
            
             *  I/O中断，用户读取磁盘需要cpu中断，发起I/O中断，每次中断则带来上下文的切换
             *  DMA技术：直接获取内存，减少中断，用户读取磁盘，DMA准备数据到系统内核缓存，用户直接将内核缓存拷贝到用户空间
             *  传统数据发送：需要1-4次copy 
                
                 *  将磁盘读取到内核缓存
                 *  将内核缓存copy到应用缓存
                 *  将应用缓存copy到网卡发送缓存
                 *  将网络发送缓存copy到网卡发送
             *  实现零拷贝需要OS的支持，Linux常见的mmap，sendfile
                
                 *  mmap（将程序缓存和内核缓存进行映射，两次DMA一次CPU拷贝（读取磁盘到内核缓存，cpu拷贝到网络缓存，DMA拷贝数据到网卡发送））
                 *  sendfile(一次cpu拷贝，2次DMA拷贝) 数据直接进入内核缓冲区，省去用户和内核缓存交互，减少切换上下文带来的消耗
                 *  splice （2次DMA拷贝，内核缓存和网络缓存直接set up pipe）
             *  java只支持mmap，sendfile
                
                 *  javaNIO中的Channel 相当于内核缓存，Buffer相当于用户缓存区，FileChannel.transferTo()就是调用的sendfile
                 *  Netty
    50. java动态代理
        
         *  就是在运行期间动态处理代理方法
         *  jdk(是基于反射实现的)，使用InvocationHandler实现接口定义的横切逻辑，利用Proxy生成代理实例，通过反射调用目标类，实现动态将业务和非业务逻辑拼接
         *  cglib(基于字节码技术，生成代理对象的子类)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIzOTQ1Njg1_size_16_color_FFFFFF_t_70]: /images/20230528/188f012ec9d54ddb986c6d28acb149b2.png