2021-05-21

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

一、MyBatis的一级缓存二级缓存

缓存，主要是为了提高查询的性能，避免了跟数据库交互的次数，来减轻数据库承受的压力
所以适用于读多写少的场景，如果变化频率非常高，那就不适用。

一级缓存：一级缓存默认开启，作用域是session级别，在获取一个对象时，第二次不会查询数据库。任何更新操作，都会清空一级缓存。

二级缓存：作用域是mapper级别，可以在mapper文件下加入 代表缓存会存储1024个对象的引用，如果超过则使用LRU（最近最少使用）算法来回收，还有FIFO（先进先出），返回的对象是只读的。

顺序：二级缓存=》一级缓存=》数据库

二、MyBatis分页插件的原理

PageHelper

  SqlSession sqlsession = SqlSessionFac.getSqlsession();
        DetailDao mapper = sqlsession.getMapper(DetailDao.class);
        PageHelper.startPage(2,2);
        List<Booktype> alltype = mapper.findAlltype();
        PageInfo pageInfo = new PageInfo(alltype);
        System.out.println("pages:总分页数"+pageInfo.getPages());
        System.out.println("navigatepageNums:分页导航"+ Arrays.toString(pageInfo.getNavigatepageNums()));

limit（）第一个参数是当前页，第二个参数是当前每页条数

他的内部实现是利用了Mybatis自带的拦截器接口，实现自定义插件，然后拦截未执行的sql，重写sql，加上带有分页的语句，实现分页。

public interface Interceptor {

  Object intercept(Invocation invocation) throws Throwable;

  Object plugin(Object target);

  void setProperties(Properties properties);

}

三、为什么使用线程池？解释一下线程池的参数？

四、redis的持久化框架

RDB在指定的时间间隔内将指定的数据写入到磁盘中。
方便持久化、在重启redis时效率高
因为每隔一段时间，所以数据容易丢失。
AOF是以日志的形式记录服务器的每一个读写操作，以文本的方式记录。
数据安全的。他有三种策略，每秒同步、每修改同步、不同步
启动效率低、AOF文件比RDB文件大。

如果redis突然宕机了，在平时工作中，这两种模式都是同时开启的，会先用RDB恢复大概的数据进行操作，在使用AOF对数据进行全部恢复。

五、mysql命中索引

六、常见的数据结构

一共有八种数据结构
数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成 。
1.数组
2.栈（先进后出）
3.队列（先进先出）
4.链表（）
5.树
6.散列表
7.堆
8.图

七、聊一下spring

可以根据这个官网图来进行介绍。

八、IOC是如何进行实现的

九、bean的生命周期

十、如何理解微服务的概念

传统的单体架构并不是不好，只是不适用于高可用、高性能、高扩展性的情况下。
微服务是一种架构的风格，一个大型的复杂软件由一个或多个微服务组成，系统中的各个微服务可以独立的进行部署，各个微服务之间也是松耦合的，每个微服务仅关注于完成一项业务。

十一、熔断

springcloud中有Hystrix断路器组件。

阻止故障的连锁反应，实现熔断
快速失败，实现优雅降级
提供实时的监控和告警

资源隔离：线程隔离，信号量隔离
线程隔离：Hystrix会给每一个Command分配一个单独的线程池，这样在进行单个服务调用的时
候，就可以在独立的线程池里面进行，而不会对其他线程池造成影响
信号量隔离：客户端需向依赖服务发起请求时，首先要获取一个信号量才能真正发起调用，由于信号量的数量有限，当并发请求量超过信号量个数时，后续的请求都会直接拒绝，进入fallback流程。信号量隔离主要是通过控制并发请求量，防止请求线程大面积阻塞，从而达到限流和防止雪崩的目的。

熔断和降级：调用服务失败后快速失败
熔断是为了防止异常不扩散，保证系统的稳定性
降级：编写好调用失败的补救逻辑，然后对服务直接停止运行，这样这些接口就无法正常调用，但又不至于直接报错，只是服务水平下降
HystrixCommand 或者HystrixObservableCommand 将所有的外部系统（或者称为依赖）包装起来，整个包装对象是单独运行在一个线程之中（这是典型的命令模式）。

超时请求应该超过你定义的阈值
为每个依赖关系维护一个小的线程池（或信号量）;如果它变满了，那么依赖关系的请求将立即被拒绝，而不是排队等待。
统计成功，失败（由客户端抛出的异常），超时和线程拒绝。
打开断路器可以在一段时间内停止对特定服务的所有请求，如果服务的错误百分比通过阈值，手动或自动的关闭断路器。
当请求被拒绝、连接超时或者断路器打开，直接执行fallback逻辑。
近乎实时监控指标和配置变化。

十二、springcloud有哪些组件

网关：gateway
注册中心：nacos
服务熔断：Hystrix
调用：feign
负载均衡：ribbon

十三、Nacos和Eureka的区别

十四、redis集群 哨兵模式

十五、什么是死锁、如何避免？

线程A独占锁资源a，并尝试获取资源b。
线程B独占锁资源b，并尝试获取资源a。
从而发生阻塞，变成死锁。

死锁代码：

public class Deadlock {

    private static final Object a = new Object();
    private static final Object b = new Object();

    public static void main(String[] args){
        new Thread(new Task(true)).start();
        new Thread(new Task(false)).start();
    }

    static class Task implements Runnable{
        private boolean flag;

        public Task(boolean flag){
            this.flag = flag;
        }

        @Override
        public void run() {
            if(flag){
                synchronized (a){
                    System.out.println(Thread.currentThread().getName()+"->获取到a资源");
                    synchronized (b){
                        System.out.println(Thread.currentThread().getName()+"->获取到b资源");
                    }
                }
            }else{
                synchronized (b){
                    System.out.println(Thread.currentThread().getName()+"->获取到b资源");
                    synchronized (a){
                        System.out.println(Thread.currentThread().getName()+"->获取到a资源");
                    }
                }
            }

        }
    }
}

//有可能会出现死锁，如果第一个线程已经走完，第二个线程才获取到执行权限，那么就不会出现死锁

减少同步代码块嵌套操作

降低锁的使用粒度，不要几个功能共用一把锁

尽量采用tryLock（timeout）的方法，可以设置超时时间，这样超时之后，就可以主动退出，防止死锁（关键）

十六、几种算法

1.冒泡排序算法
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。

 /*
 * 冒泡排序
 * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。  
 * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。  
 * 针对所有的元素重复以上的步骤，除了最后一个。
 * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 
 * @param numbers 需要排序的整型数组
 */
public static void bubbleSort(int[] numbers)
{
    int temp = 0;
    int size = numbers.length;
    for(int i = 0 ; i < size-1; i ++)
    {
    for(int j = 0 ;j < size-1-i ; j++)
    {
        if(numbers[j] > numbers[j+1])  //交换两数位置
        {
        temp = numbers[j];
        numbers[j] = numbers[j+1];
        numbers[j+1] = temp;
        }
    }
    }
}

2.快速排序
a、确认列表第一个数据为中间值，第一个值看成空缺（低指针空缺）。
b、然后在剩下的队列中，看成有左右两个指针（高低）。
c、开始高指针向左移动，如果遇到小于中间值的数据，则将这个数据赋值到低指针空缺，并且将高指针的数据看成空缺值（高指针空缺）。然后先向右移动一下低指针，并且切换低指针移动。
d、当低指针移动到大于中间值的时候，赋值到高指针空缺的地方。然后先高指针向左移动，并且切换高指针移动。重复c、d操作
e、直到高指针和低指针相等时退出，并且将中间值赋值给对应指针位置。
f、然后将中间值的左右两边看成行的列表，进行快速排序操作。
g、代码实现

public static void main(String[] args) {

        int arr[] = {7, 5, 3, 2, 4, 1, 8, 9, 6};

        //快速排序
        int low = 0;
        int high = arr.length - 1;
        quickSort(arr, low, high);  
    }

    public static void quickSort(int[] arr, int low, int high) {
        //如果指针在同一位置(只有一个数据时)，退出
        if (high - low < 1) {
            return;
        }
        //标记，从高指针开始，还是低指针（默认高指针）
        boolean flag = true;
        //记录指针的其实位置
        int start = low;
        int end = high;
        //默认中间值为低指针的第一个值
        int midValue = arr[low];
        while (true) {
            //高指针移动
            if (flag) {
                //如果列表右方的数据大于中间值，则向左移动
                if (arr[high] > midValue) {
                    high--;
                } else if (arr[high] < midValue) {
                    //如果小于，则覆盖最开始的低指针值，并且移动低指针，标志位改成从低指针开始移动
                    arr[low] = arr[high];
                    low++;
                    flag = false;
                }
            } else {
                //如果低指针数据小于中间值，则低指针向右移动
                if (arr[low] < midValue) {
                    low++;
                } else if (arr[low] > midValue) {
                    //如果低指针的值大于中间值，则覆盖高指针停留时的数据，并向左移动高指针。切换为高指针移动
                    arr[high] = arr[low];
                    high--;
                    flag = true;
                }
            }
            //当两个指针的位置相同时，则找到了中间值的位置，并退出循环
            if (low == high) {
                arr[low] = midValue;
                break;
            }
        }
        //然后出现有，中间值左边的小于中间值。右边的大于中间值。
        //然后在对左右两边的列表在进行快速排序
        quickSort(arr, start, low -1);
        quickSort(arr, low + 1, end);
    }

十七、时间复杂度、空间复杂度

时间和空间是程序的一个硬性指标，一个用来衡量 代码执行的速度 ，一个用来衡量 存储空间的大小
程序 = 数据结构 + 算法
时间复杂度：就是执行程序的快慢，速度越快，时间复杂度就越好。
空间复杂度：就是执行程序需要的存储空间的大小，执行程序需要的存储空间越小就越好。

十八、java文件变成字节码文件的过程

我们一般通过 javac test.java 命令转成test.class 也就是字节码文件
其中会经过
词法解析：将Java关键字排序，使得程序能有序运行。
语法解析：词法解析后的Token序列整合为一颗抽象的语法树。
语义解析：将抽象语法树扩展地更加完善。
字节码解析：将字节码解析成完整的类。
一些解析的过程。