java八股文学习导图

一、javaSE基础

1、关键字
2、面向对象的特性
3、基本数据类型
4、对象类型
5、包装类型

二、Git/svn/Maven/IDEA

1、Git代码管理
2、Svn代码管理
3、Maven库/IDEA

三、多线程\原理\并发类库(Semaphore,CountDownLatch,CyclicBarrie)\线程池\线程安全\锁

1、多线程创建方式
2、线程池
3、并发类库（Semaphore,CountDownLatch,CyclicBarrie）
CountDownLatch:
线程计数器，线程执行任务完成，线程计数器减一，并且可以调用await()方法等待线程执行完成，后再执行其他线程；只有计数的线程完成执行任务，其他线程才能继续执行；
相当于给线程计数，只有计数线程都执行完毕，其他线程才能执行；
也可以使用join方法操作线程的执行顺序；
例子：
打印批量试卷，并最终统计总分
主线程等待其他线程执行完毕后，最后执行主线程
Semaphore:
计数信号量：相当于给线程手动加锁，获得锁就执行，锁没释放就会造成线程阻塞（许可）
提供两个方法：acquire();release();
CyclicBarrie；
当一组线程达到一个状态，才能执行；
例子：
学生放学回家，出于安全，门卫要求达到3个人才能出校门；
4、锁
synchronized锁，修饰方法和代码块，非公平锁，每个线程都会尝试获取锁的资源；
锁的升级原理：
偏向锁，轻量级锁，重量级锁
第一个线程获取锁，偏向锁，CAS操作将线程id记录到对象头，下次该线程获取锁资源就不需要同步操作，其他线程获取锁资源就会存在锁的升级过程，比较并替换锁的对象头标志位；
锁的升级:偏向锁：只有一个线程去获取资源,可以不释放锁
轻量级锁：多个线程竞争锁的资源,考虑到需要释放锁,从用户态切换到内核态,需要消耗资源就替换成轻量级锁
重量级锁:为了考虑同一个时间多个线程竞争资源是升级成重量级锁
Lock锁
ReentrantLock可重入锁

5、线程方法
Join()等待调用join（）的线程执行完毕后，在执行其他线程
Await()，将线程暂停,处于一个等待状态,只有当其他线程调用notify,notifyall才能唤醒这个线程，它是释放锁的
Sleep()方式，是将线程睡眠一段时间，是thread类提供的方法
其他方法是object()类提供的方法。

6、CAS
比较并替换,底层是基于Unsafe类下的方法实现的比较并替换操作,可以比较对象,int,long，提供了相应的比较并替换方法,该类是不运行直接new 的，因为他的构造函数是私有的,使用Unsafe类是比较危险的,它可以直接修改私有变量的，修改内存。
使用cAS常见问题就是会产生ABA问题
ABA问题就是一个线程将A修改成B后又改成A，其他线程读取的时候就，做Cas替换的时候就导致内存值和预期值相同,而不考虑到值的改变过程.
解决方式:使用原子引用,既是使用提供的原子类操作,每修改一次值就标记一下它的版本,记录这个修改的过程.
CAS的应用场景:锁的升级过程就是采用CAS机制来替换锁的
7、AQS
提供大量的模板流程方法
AQS底层数据结构:
使用volatile 修饰的state标志，线程的可见性，线程修改值后，保证能看到它的变化
state为0时，锁没被占用,1的时候锁被占用
用cas比较并替换的方式实现状态值的改变过程,标记为0,或者1,标记锁的状态
同步队列
非公平，公平
8、volatile的作用
线程操作变量的时候,保证变量值的一个可见性，其他线程都可以到主内存中获取到改变的值，防止指令重排序.有序性，不保证原子性

四、JVM内存模型\分区\垃圾回收机制\对象引用\内存泄露\CPU飙高

1、Jvm内存模型
方法区（1.6后元空间）；堆；栈；本地方法栈
2、内存分区
新生代，老年代；
元空间:
存储常量池、变量、类信息、等
堆:对象分配内存的地方
栈:存储方法的执行地方，线程私有的，每次执行方法的时候都会产生栈帧,最好的例子就是递归算法.
内存溢出：大量的对象没有被垃圾回收,导致内存不够,造成内存溢出异常
栈溢出:线程执行的深度大于栈的深度,线程阻塞
堆内存分布:年轻代，老年代,1:2
年轻代的存活对象会慢慢进入到老年代
年轻代分为块:emed:from :to8:1:1
编译class文件,经过类加载器加载到jvm中,经过jvm的引擎进行处理
双亲委派机制:
每次加载一个类,首先都是去委派给它的父类进行加载,当它没有父类的时候m就加载该类,保证class文件不会重名,不会出现相同的类。造成冲突

3、垃圾回收算法机制
GC垃圾回收算法:
标记清除：没有引用的对象都进行标记处理后，统一回收,并进行内存整理，这种垃圾回收如果遇到大对象的时候很难控制，内存会碎片化
复制：将内存空间分成2半,一半使用,另一半保存,其中一半进行垃圾回收,让后将存活对象,复制到保留的内存里面,最后将这半内存给清空处理。存活对象过多的话,内存不足.
标记整理：将回收对象进行标记,将存活对象往一边进行移动,最后清除边界的内存,解决了内存碎片化,内存对半分造成内存不足的问题.
标记整理:
内存对象转移过程：
在年轻代存活对象经过MinrGC一系列操作,进入老年代.,最好经过fullgc清除对象,如果老年代内存过多,导致垃圾回收慢。
类加载过程:

4、对象引用
强引用；弱引用；虚引用
5、内存泄露、内存溢出
内存泄露：大量对象占用内存，无法被垃圾回收器回收；
内存溢出：cpu内存不足，无法创建出更多对象；
6、Cpu飙高解决问题
使用top命令查看cpu占用率高的进程，通过占有率高的进程id输入top -Hp pid 命令，查看到该进程下占用cpu高的线程，将进程id转换成十六进制，通过jstask 命令生成堆栈信息文档，根据十六进制id查看线程异常情况，找到对应代码。
7、垃圾回收流程
找到垃圾对象有两种算法：
引用计数算法：将java中被引用的对象加+1，不被引用就减1,当该对象引用为0时，就需要回收这个垃圾对象。(缺点：对象相互引用的情况下，它的引用计数不可能为0)
可达性分析算法：大多数都是使用这种算法去查找垃圾对象,使用的gcroot作为根节点的方式去引用其他对象，如果其他对象被引用在这个引用链上,那么没在引用链上的对象就是垃圾对象.
回收垃圾的4种算法：
标记清除：
复制算法：
标记整理：
分代算法：
这四种算法是给年轻代和老年代使用的，分代算法，是选择性的使用其他算法

一般年轻代使用复制算法，而复制算法的缺点就是存在内存浪费的情况，总会有个s0或者s1被空出来，而复制算法就是将存活对象复制到保留内存中，当前这半内存就直接清除，所以这三个区域就会存在2个一循环的使用内存，每次就是通过垃圾收集器gc一下，标记引用次数，达到16的时候，就引用时间长了直接推送到老年代，在通过fullgc清除

在年轻代gc的过程是清除垃圾对象的同时，甩出存活对象引用次数较多的对象给老年代，最好在老年代统一标记清除。年轻代：老年代=1：2；老年代存放的是长期存活的对象
垃圾收集器:
GC、G1、CMS

五、Spring

1、IOC(控制反转)
控制反转，对象的调用不是自己调用，而是交由Spring容器调用,将对象通过Bean的方式，配置再Spring容器中，通过依赖注入的方式，实现对象调用。
2、DI（依赖注入）-解决循环依赖问题
依赖注入的方式：
注解注入\构造函数注入
循环依赖：A对象依赖于B对象，B对象依赖于A对象（Bean）;相互注入依赖
解决方式：使用setter方法注入，按需注入，使用@Lazy注解，Bean只初始化创建一次
3、Bean的生命周期
Bean的实例化=》Bean的属性注入=》加入Spring工厂=》调用=》销毁
4、Aop底层原理（Jdk的动态代理等）创建代理对象增强目标类
对原有类对象，代码的一个增强；
连接点：
切入点：
通知：
注解：@Aspect
Jdk动态代理：必须有接口和实现类，通过Proxy工具产生代理类，从而对目标类进行增强。
Cglib代理：生成的代理类为目标类的一个子类；
应用场景：自定义注解，切换数据源
5、Spring事务
事务隔离级别：
事务传播行为：

六、SpringMvc

1、SpringMvc的执行流程
用户发送请求到DispatcherServlet；收到请求调用HandlerMapping处理器；调用适配器；
执行完成返回ModeAndView，返回给DispatcherServlet，将结果返回给视图解析器；解析后返回view，进行渲染

七、MyBatis

1、Mbatis开启二级缓存
2、#和$
3、动态sql
4、其他

八、SpringBoot

1、SpringBoot自动装配原理
2、其他

九、Vue/HTML/CSS/JS

1、js基础
2、css基础
3、Vue-router
4、Vuex
5、Vue生命周期

十、Mysql

1、Mysql引擎、底层结构
2、Mysql事务
3、其他

十一、Oracle

1、序列
2、执行顺序
3、聚合函数
4、索引
5、序列
6、Sql优化

十二、Redis

1、基本数据类型
String set get key-value
List lpush key-value 栈队列阻塞队列
Hash key map
Set sadd myset wxs set添加值 无序不允许重复
Zset 有序，设置值是需要添加序号
Redis事务：
开启事务（multi）
命令入队（…）
执行事务（exec)
支持事务，只有执行事务命令事务才能执行

2、事务
3、命令
4、缓存穿透
5、缓存雪崩

十三、集合、队列

1、ConurrentHashMap
2、HashMap
3、ArrayList
4、linkedList
5、LinkedListHashMap
6、HashTable
7、HashSet

十四、SpringCloud-微服务

1、zull网关
2、hysiex熔断器
3、ribbien负载均衡
4、其他

十五、SpringCloudAlibaba-微服务

1、nacos
2、gateWay网关
3、State

十六、权限认证

1、shore
2、SpringStrity

十七、Docker

1、常用命令
2、打包镜像
3、Dockefile脚本
4、K8s

十八、Linux

1、常用命令操作

十九、分布式问题

1、分布式事务acp/base理论

二十、消息队列

1、RketMq

二十一、搜索引擎（ES）

1、elselsearch
常见面试题:
String s1=“wxs”;
String s2=“wxs”; //创建对象在常量池中
System.out.println(s1s2);
String s3 = new String(“wxs”); //创建2个对象
System.out.println(s1s3); //对象的存储地址不同
System.out.println(s1.equals(s3)); //比较内容是否相等
StringBuilder s4 = new StringBuilder(“wxs”);
System.out.println(s1+“wer”); //重新创建新对象存储//需要拼接字符串时需要使用StringBuilder或者–，改变的时对象

序列化、反序列化
应用场景：在创建pojo对象类的时候需要对对象的属性进行序列化实现Serializable接口
序列化：将java对象转化成字节序列的过程，字节流方便网络传输，减少存储，永久保存
对象中不需要被序列化的加上transient关键字

泛型：
泛型可以是修饰在集合方法类上，对该修饰的对象进行限制他的一个类型,存在其他类型就会报错

反射：运行时获取类的信息，jdk的动态代理
获取对象信息的方式
Class.forName(“java.io.String’)
对象.class
对象.getClass
包装类.type
创建对象：