面试八股加油背

树形

图形

集合

线性

链式

顺序

做一件事情能不能立即得到返回应答，如果不能立即获得返回，需要等待，那么就阻塞了，否则可以理解为非阻塞

阻塞是指一个服务调用另一个服务以后他只能够等待调用的服务完成再进行操作

非阻塞就是当一个服务调用了另一个服务以后它可以进行其他服务

做完一件事情以后再去做另一件，不管是否需要时间等待

异步就是可以同时做很多件事，并不一定需要一个做完以后再做另一个。在调用结束之后，通过消息回调来通知调用者是否调用成功。

同步是指一个服务调用另一个服务以后只能等待这个服务的结果完成后再进行下一步

异步就是通过异步的结果回调

时间换空间，在第一次访问实例的时候创建

有线程安全的问题

使用静态内部类实现懒汉式

用空间换时间，在类加载时就创建

没有线程安全问题

枚举类实现饿汉式

有一个代理对象和目标对象，目标对象实现具体的业务，两个对象实现同一个接口，业务在调用时调用
代理对象的方法，代理对象内部有一个目标对象的属性，在执行方法时执行目标对象的方法，同时加上业务

JDK动态代理

CGlib动态代理

通过静态方法传递不同的参数实现创建不同的对象

1、一个目标对象被多个 观察者观察 List<Observer> observers;
2、目标提供对观察者注册和退订的维护 attach(Observer observer)、detach(Observer observer)
3、当目标的状态发生变化时，目标通知所有的注册的观察者 notifyObservers()方法通知所有观察者

通过设置抽象工厂，让工厂类符合开闭原则，工厂类都实现工厂接口，在创建工厂时创建抽象的引用，new出具体的实现类，来实现开闭原则，
在扩展时不需要修改业务代码，只需要更改new出的具体的工厂对象即可

缺点是对于每一种产品都需要创建对应的工厂，使项目中的类的数目增多

抽象工厂就是在工厂模式的基础上增加了产品簇的概念，就是对于一个工厂，他不但能生产一种类型的产品，它有多个
create方法去创建不同类型的产品去形成一个产品簇

对于修改关闭，对于扩展开发，意思就是在扩展程序的功能时
应该尽量少的去修改原来的代码，而是在设计时提供灵活的扩展
方式

比如对于工厂方法模式，就是扩展产品只需要编写对应的产品工厂以及产品类，在创建时修改具体的实现类
就可以扩展能添加的产品

当软件发生变化的时候，通过拓展来实现变化而不是通过修改实现变化，因为原有的功能可能被其他类所引用，如果修改的话会
影响其他类的使用

最少知道原则

类与类之间的调用应该保持最少的了解
只是用public的方法进行调用

核心就是面向接口编程，业务代码应该依赖于抽象而不是依赖于具体的实现类
也就是让实现依赖于抽象，而不是让抽象依赖于具体

子类应该可以替换掉父类

流量控制

拥塞控制

校验和

超时重传

JVM无法对于反射的代码进行优化，所以反射的效率会比非反射的效率慢很多

反射允许代码一些普通代码无法执行的操作，比如访问对象的私有变量，这样就破坏了代码的抽象性

首先将Key和value封装成一个node对象，将key的值
使用哈希算法进行哈希运算，得到数组下标，然后根据数组下标
到hashmap对应的数组中查找，如果数组为空，那么将node对象存放在该数组的位置
如果数组不为空，那么一次从头开始使用equals方法对key的值进行比较，
如果返回是true，那么就将链表中对应的value值覆盖，
如果返回都是false，就将节点放置在链表的尾部

首先将Key进行哈希运算获得数组下标，然后通过下标查找数组，如果对应数组中
没有值，就返回null，如果有值就依次与节点的key执行equals方法，如果返回true，
就返回对应的value值，如果都是false，就返回null

如果重写hashcode方法，那么所有的哈希返回值都不同，最终哈希表
会退化成一个数组
如果不重写equals方法，所有添加的节点的equals方法只要不同就会返回false,
最终他会退化成一个链表

通过hashcode方法和equals方法保证，对于传入的key首先通过两次hashcode()运算再去取余他的容量
来获得对应的数组下标，如果对应下标没有数据，就将对应的node存储在位置，如果有数据就会执行equals方法
如果返回为true就覆盖对应的value值，如果为false，就在链表的尾端添加对应的node

jdk1.7

jdk1.8

hashmap是线程不安全的，hashtable是线程安全的，因为hashtable底层使用了synchronized锁来保证线程
安全性，

hashmap使用了数组+链表/红黑树，hashtable使用了数组+链表

hashmap允许null为键和value,hashtable不允许

hashmap效率高，hashtable效率低

简化参数类型

简化括号

简化花括号

流操作

调用start方法启动

传入目标对象+Thread().start

使用标志位flag来停止

利用次数让线程自动停止

不要使用stop方法来停止线程

要让线程在内部自动停止，而不是调用外部方法停止线程

让线程进入阻塞态指定的时间，每一个对象
都有一把锁，sleep不会释放锁

合并线程，当当前线程执行完毕后其他线程才能执行，其他线程阻塞

线程的礼让，让当前的线程进入到阻塞态
礼让不一定会成功，会让cpu重新调度

wait方法时线程停止并且释放锁，进入到等待池中，直到其他线程调用notify/notifyall方法将他唤醒，它才会去重新申请锁资源，进入到就绪态和
运行态

sleep是Thread类下的方法，它可以在任何线程中使用，而sleep方法只能在线程同步有锁的场景下使用

sleep方法不释放锁执行后依然会对线程进行监控，而wait方法执行后会释放锁

wait是Object的方法，sleep是Thread类的方法

wait会释放锁，sleep不会释放锁，还是对线程进行监控，在达到要求的是时间以后
会进入到就绪态，wait会释放自己的锁资源，进入到等待队列中去，等待其他的线程
notify/notifyall唤醒它，再去获取锁，进入到就绪态再到运行态执行

对于java中创建线程和销毁线程的开销特别大，如果一个jvm中创建过多的线程
那么可能会使系统资源不足，为了防止资源不足，采用一些方法来限制给定时刻处理的
目标请求数目，尽可能的减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程
的创建和销毁，尽量利用已有对象来进行服务

首先会查看核心线程数量满没满，如果没满直接创建线程来执行任务

如果核心线程满了，那就将任务存放到阻塞队列中去，等待核心线程执行完毕后再创建线程执行

如果阻塞队列满了，那么就继续创建线程来执行任务，直到达到线程池规定的最大线程数

如果到达线程池规定的最大线程数，那么就直接执行拒绝策略（四种

参数

创建的方法

核心线程数设置

乐观锁

公平锁：就是对于线程执行必须先来先执行，不允许插队

非公平锁：允许插队，比如对于一个3s的线程和一个3h的线程，可以让3s的先执行
不需要等待3h才执行

synchronized和lock默认都是非公平锁，lock锁也可以设置成非公平锁

表示一个线程如果之前获得了锁，还可以再增加锁而不会产生死锁，加多少次锁就需要
解多少次锁

ReentrantLock 和synchronized 都是 可重入锁

通过lock方法加锁通过unlock方法解锁，对于加锁和
解锁必须严格使用try catch finally代码块进行保护，对于加锁
必须有对应的解锁，防止产生死锁

ReentrantLock

ReentrantReadWriteLock

ReentrantReadWriteLock.ReadLock

ReentrantReadWriteLock.WriteLock

synchronized是java自带的关键字，lock锁是一个java类

synchronized会自动解锁，而lock锁需要手动解锁

synchronized不可以判断是否加锁，而lock有isLock方法判断是否加锁

synchronized锁的线程会一直等待，而lock锁有trylock()方法判断能否加锁，设定等待一定
时间后结束

synchronized适合少量同步的代码，lock锁适合大量同步的代码

synchronized和lock都是悲观锁，synchronized是非公平锁，lock默认是非公平锁，可以设置成公平锁

循环判断

修改资源

通知其他线程

当一个线程修改一个共享变量时，另一个线程能够
读到修改的这个值

比如对于i++，就是不保证原子性的，i++分为三步，
1.读取i的值
2.将读取的值+1
3.将结果赋值给i
对于这种情况，当读取完i的值之后另一个线程完成了对
i的值的修改，就会导致结果赋给i时出现错误，不保证原子性

AtomicIntege保证运算的原子性

对于单例模式的双重检查机制，如果发生指令重排可能
会导致检查发生错误，因此需要加volatile关键字

需要写入的内存地址

存入前他的预期值

需要存入的值

优点是不需要进行线程状态切换，进行线程切换会消耗性能

缺点是他是自旋锁，也就是一直会循环判断浪费时间，
并且由于是基于cpu的操作，它只能保证一个共享变量的原子性

为什么要解决ABA问题？

如何解决ABA问题

AtomicStampedReference就可以解决ABA问题，AtomicInteger类就存在ABA问题

互斥条件

请求和保持条件

不剥夺条件

环路等待条件

只要打破四个必要条件之一就能有效预防死锁的发生

实现多个线程之间资源对象的线程隔离，对于不同的线程创建不同的资源对象，对于线程
内部，调用同一个资源对象

因此它还有第二个作用，就是实现线程内的资源共享

比如对于jdbc操作，当你需要在service层中执行两条SQL语句时，如果每条SQL语句都创建新的
Connection连接对象，那么就会导致无法实现事务，事务需要在同一个连接内进行开启和回滚，因此
就可以使用ThreadLocal来创建sql连接对象，方便一起进行事务的回滚和提交

具体的实现就是，当调用getConnection对象时，会先检查ThreadLocal对象中有没有Connection对象
如果有就代表该线程的之前的方法已经创建过连接，就直接返回连接，如果没有就创建新的连接存在ThreadLocal中

如果这样的话如何关闭Connection呢，对于jdbc来说，以前每执行完sql就用finally关闭connection
而对于ThreadLocal创建的对象如果这样就没有意义了，因此要在service层中创建生成连接对象并用finally
在线程层面上去关闭连接

ThreadLocal底层做了一个ThreadLocalMap，类似于hashMap实现了线程的隔离

方法

静态代理

动态代理

通过@Aspect注解来定义切面

设置通知的类型

PointCut切入点

在程序中创建具体的实现类会使代码的耦合性太高，我们希望能够只面对接口编程，而不出现具体的实现类

将具体的实现类交给Spring容器去管理和创建

将Spring容器中的bean的中的属性进行赋值

注入的方法

通过标签注入

一级缓存

二级缓存

常用的标签

mybatis它是对jdbc的封装

他可以很轻松的实现数据库单表和多表之间的操作

他有动态标签可以简化sql操作

有一级缓存和二级缓存来提高查询的效率

首先请求会发送到一个DispatcherServlet,他是作为一个控制中心

然后接收到请求后，他会根据请求的路径去向HandlerMapping请求路径对应的方法

获得对应的Handler方法以后，他会去请求HandlerAdapter去执行对应的Handler方法，
Adapter找到对应的Handler方法执行完毕后会向DispatherServlet返回一个ModelAndView对象

收到以后，回去视图解析器将视图的路径解析到真实的路径，然后再通过View去渲染视图

最后返回接收到的数据通过response返回

Filter是servlet中的概念，他只能在web项目上使用
Interceptor拦截器是Spring的组件，除了web项目在其他的Spring项目中也能使用

过滤器和拦截器的出发时间不同，过滤器先触发，在进入Servlet再进入Interceptor，再
进入Controller

preHandler

postHandler

afterCompletion

controller是单例的

阿里巴巴编码规范要求不要在controller里定义成员变量

如果一定要定义非静态成员变量，就通过通过注解@Scope(“prototype”)，将其设置为多例模式

controller中可以使用ThreadLocal来实现controller中的成员变量

bean的获取/创建流程

首先解决当A包含B，B包含A时，如何不循环创建

再解决aop代理对象所产生的问题，单例池中应该是代理对象而不是目标对象

首先通过三级缓存 单例池 半成品池和工厂池来解决循环依赖问题，当A实例化以后，他会在工厂池中创建对应的factory(a),然后开始进行属性注入
当注入时需要beanB,那么开始创建beanB，首先实例化B,然后在工厂池中创建factoryB,然后注入beanA，此时通过factoryA,去调用aop的前置处理
去创建a的aop代理对象在半成品池中，然后将a的半成品注入到B中，然后完成B的初始化，初始化以后调用beanpostprocesser对应的aop后置处理创建
aop的代理对象放到单例池中去，然后删除工厂池中的factoryB,然后对A进行属性注入B（从单例池中），然后完成BeanA的初始化，同时检查有没有提前
生成aop的代理对象，有就将半成品池中的bean放到单例池中，然后删除factoryA,完成beanA的初始化

在controller层上添加类上加上@restcontrolleradvice在里面的方法上加上@ExecptionHandler

不但是存储字符串，也能存储二进制数据，数字等等，可以使用方法将数字+1（文章点赞记录），可以接收任何格式的数据，图片也可以，最多
512M

用于实现个人信息的展示和购物车信息的展示

用于实现一些集合操作，并集交集差集，用来实现小程序抽奖（随机获取set集合中的指定的值，有两种方法spop和SRANDMEMBER分别代表会将
抽中的数据删除和不删除抽中的数据）以及共同关注的人功能

它是一个双端的队列，可以作为消息队列

可以用作各种排行榜，权重就代表热度

攻击者故意搜索id特别大或为-1的不存在的数据
增加数据库的压力

解决方案，对于没有的数据也在redis生成一个过期时间为1分钟的缓存数据

对于数据库中有但是redis中没有的数据，用户并发量过大，导致数据库
压力增大

解决方案

在某个时间点，大量的缓存失效，导致数据库瞬间需要承载大量请求，导致数据库宕机

解决方案

redis事务分为两个阶段，一个是组队阶段，一个是执行阶段

multi开启事务

exec执行事务

discard放弃事务

redis事务的特性

如果在排队阶段的命令有语法上的错误（就类似于编译时错误），那么就不会进入执行阶段，直接报错

但是如果是运行时错误，比如说对于一个字符串进行+1操作，在运行时才能发现错误，这种操作即使报错了也不会进行回滚

悲观锁解决问题

乐观锁解决问题

redis秒杀场景

redis秒杀产生的问题

redis的数据备份文件，也就是将redis中的数据备份到磁盘中去，当redis
出现宕机，就可以根据RDB文件去恢复redis中的数据

每次redis服务端关闭时都会自动的执行一次RDB，来实现数据的持久化操作

RDB的操作

配置文件中可以设置RDB的文件名，RDB的频率

AOF追加文件，将redis的所有写命令写入到aof文件中去

默认是关闭的

aof的三种频率

为了解决aof文件过大的问题，引入了bgrewriteaof命令

将B设置为A的从服务器，方法就是在B的客户端上执行slaveof A的ip地址 A的端口

全量同步

增量同步

主从同步的优化

哨兵的作用

哨兵的服务状态监控

选举新的master

故障转移

类加载器

双亲委派机制

验证

准备

解析

对于静态资源在<clinit>类加载器方法中初始化，执行静态代码块里的操作和静态变量的赋值操作

堆相关

栈相关

程序计数器

引用计数法

可达性算法

标记-清除算法

标记-清除-压缩算法

标记复制算法

分代

B+树索引

hash索引

R-tree索引

全文索引

为什么不用其他数据结构？

复合索引

单一索引

主键索引

唯一索引

二级索引（辅助索引

聚集索引

对于索引，存在最左前缀法则，也就是索引最优先根据最左边的字段进行查询，如果中间断开也会差生索引失效
比如你有ABC，三个字段的联合索引，那么如果你只根据A和C进行查询，那么索引到B就会失效，导致BC的索引都无法使用

模糊查询首部不要进行%匹配，不然会导致索引失效

对于or关键字如果一边字段没有索引就会索引失效

不要在索引列上增加函数运算否则索引失效

索引尽量使用>=，<=,如果范围匹配只有> 和<，索引会失效

字符串不加单引号会形成隐式类型转换导致索引失效

如果mysql认为全表扫描比用索引快，索引失效

is null 和 is not null也会引起索引失效

80%还是通过索引

当数据达到百万级时，再考虑

对于数据量比较大的查询使用索引

添加索引的字段应该重复性不高

主键和外键必须有索引

对于过长的字段不应该加索引，如果加可以对于字段的前几位加索引

如果可以尽量使用复合索引

DML（数据库操作语言，也就是增删改）支持ACID特性的事务

行级锁，提高并发性能

支持外键

逻辑存储结构

架构

不支持事务，不支持外键

支持表锁，不支持行锁

访问速度快

表结构和表数据是分开存储的

锁定数据库中的所有表，让整个数据库处于只读状态，在进行数据库备份时使用
在备份期间不能更行，如果从从库上备份会造成主从库延迟
也可以使用快照读来进行备份

表锁

意向锁

元数据锁

每次锁住对应行的数据，锁定的粒度最小，发生冲突概率最低，并发度高，Innodb引擎支持
行锁通过对于索引上的索引项来加锁实现的而不是对记录加锁

行锁

间隙锁

临键锁

间隙锁和临键锁是为了锁住一定范围的数据，防止产生幻读的问题

原子性

一致性

隔离性

持久性

产生的三个问题

保障事务的持久性

当执行update delete insert语句时，会首先从内存缓冲池中找有没有对应的数据，如果没有就会去磁盘将对应的数据更新到缓冲区，
然后再在buffer pool缓冲区中更新数据 更新完成后提交事务，然后缓冲区中被修改的数据页被称为脏页，会按照一定的频率将脏页刷新到
磁盘空间中去，而这时如果磁盘刷新发生错误，就无法保证数据的一致性，这时就要引入redo log 日志，redo log 是一个物理日志，会存储
数据页的数据变化，他为两个部分，一部分在缓冲区，一部分在磁盘中，当事务提交时，会同步将缓冲区的redo log 日志刷新到磁盘中去，如果刷新磁盘
产生错误，就会借助redo log 日志来恢复，保证数据的持久性

保障事务的原子性

undo log日志是一个逻辑日志，它会记录事务执行的sql语句修改前的数据，在事务回滚时，通过undo log日志实现数据的回滚，恢复到
事务开始之前的状态，保证原子性，同时undo log并不都会在事务提交后删除，Insert语句的undo log会立即删除，而update delete语句会保留
形成版本链，用于MVCC，并且配合两个隐式的字段 最近修改的事务ID，上一个版本的地址引用保证事务的隔离性

保障事务的隔离性

当前读

快照读

undo log版本链

readView

RC 和RR隔离级别下的MVCC区别

union和unionAll都是将两个sql查询结果合并，区别是union它会将查询的相同查询结果合并，而unionAll不会合并

varchar是不定长存储
char是定长存储

从速度上定长的速度快

varchar因为是不定长的所有需要有一个数据表示存储了多少长度

如果对于长度有时候很长有时候很短的，这种如果用char存储空间利用率
就很低，就最好用varchar

对于性别这种一个1长度的就最好用char，利用率高，查询速度快

内连接就是匹配两个表中符合on连接条件的所有行

外连接

from语句

where

group by   having

聚合函数

select

order by

尽量避免使用子查询

读取尽量用limit，不要全部查询

字段不要用*,而是查询需要的字段

用in来代替or

禁止没必要的orderby

避免全表扫描

alter table table_name  add index ('coloum1');

round()四舍五入

floor 向下取整

ceil()向上取整

用户传过来的技术会经过springCloudGateway网关，去注册中心去进行注册与发现，
再去具体的微服务进行访问

SpringCloudGateway

服务集群就是多台服务器开启同样的服务，负责相同的服务

对于微服务的调用，不只调用一台服务器的服务，而是根据调用的策略去进行调用，比如随机调用、轮询调用策略

所有的微服务都会去注册中心去进行注册，让注册中心去进行分配调用

服务限流就是说对于服务接收大量的请求，会使用服务限流策略，限制一部分流量的进入

对于有些依赖其他服务的服务，可能服务会出现异常，导致整个服务的资源被占用（多个线程都在等待这个服务），
此时会有一个异常比例的概念，如果异常比例达到会直接切断这个服务，以免局部的异常导致整个服务的资源崩溃

使用seata实现分布式事务，对于单体应用来说，事务可以使用trational注解来实现，但是对于分布式系统，服务
都是分离的，比如对于支付订单，可能需要调用支付，仓库，订单相关的微服务来一起完成，这个时候就无法使用
trational注解来实现，因此使用seata实现分布式的事务，保证操作的原子性

使用seata完成