一、前言
我是找的Java相关的岗位，所以只能按照Java的思路来说，如果有说的不对的地方，请大佬指教
二、个人介绍
末流985，之前一直是C\C++，后来转的Java方向，Java学习时间比较短，在2020年实习和秋招，有幸拿到了一些offer，再次也是感谢很多人给与的指导与帮助，首先是JavaGuide的知识星球还有面试经验，还有芋道源码的知识星球中提供的源码---我觉得对于自己知识的提升还是很高的。
三、实习和秋招offer情况
实习（很多人把春招当成实习，我也不太只熬到为啥），实习的话，我也就是投了几家
- 京东
- 三七互娱笔试刷
- 广联达
- 华为，等了一个多月的主管面，放弃了
- 联通软件研究院（最水的面试）
秋招
- 字节跳动国际化offer
- 腾讯PCG的offer
- 美团交通事业部offer
- 百度offer
- 好未来学而思网校offer（捞起来的）
- 华为电话意向，
- 京东offer，
- 地平线意向书（已拒），
- 大华offer，
- 平安科技offer，
- 海康威视offer，
- 小米offer
- 顺丰科技意向书，
- 云从科技意向书，
- 广联达offer
- 度小满offer
- 车好多（瓜子二手车）offer
- 中国移动的几个offer，请看帖子
- 山东的国企，请看帖子
虽然不是最好的，但是也是比较满意了，也算是结束秋招了，肯定跟大牛没发比
四、实习与秋招总体感受
今年感受最大的几点感受
- 学历感受
从今年开始，因为内卷的原因，公司招人会有首选学历好的，这个确实没有办法，无法弥补
- 实习的重要性
因为实习是证明一个人的能力，有一个很好的实习机会，在秋招看来确实很占优势
- 竞争变大
今年不论找实习还是秋招的第一个感受就是竞争变得很大，内卷也很严重，尤其是Java后端方向，竞争相当激烈，2019-2020年找工作的其实只要会Java，做不做这个方向其实无所谓，但是今年的简历筛选确实进行了一定的限制。
- 算法考查难度变深
其次是对于算法的考查难度确实提高了不少，因为今年人数过多，只是依赖于Java基础已经不能满足要求了，所以算法一定要好好耍，起码你把leetcode的1-300题刷完，因为我准备的很晚，所以只是很粗的刷到了1-200题，但是我觉得现在要求真的很高了，如果你还是算法小白，算法我觉得首选左程云视频课程，附以labuladong的那本算法小抄还有leetcode的题目，还有牛客
- 对于基础知识开始变得很深，不能在简单的看面经了
再者就是，Java知识点的深度有所加强，这个地方我就举个例子吧
面试官:你了解arraylist呢？
我:不拉不拉。。。。。（说了一个支持快速访问）
面试官:那为啥他支持快速访问呢？arraylist哪一部分去做的这个工作？
我:。。。。。（你知道不？）
等等吧，反正深度确实增加了
我觉得目前看源码是必要的， 比如说常用的java类源码，为什么arraylist是支持快速随机访问？为什么他支持序列化，其实源码当中不管是JDK作者还是自己看都会找到原因，而面试题也是从这里面来的，还有面经最少不要看太通用的，因为你越通用，到时候越难以有区分度，就像为什么同样一个答案有的人能拿5分，有的人能拿10分一样，面经也要有自己的积累，我自己也总结了超级多的面经，可以留言
- 测评的重视程度
测评一定要好好做，今年内卷严重，为了刷人，测评如果不好好做就是被刷掉了，现在大部分采用的是北森的题库还有几家是自己的题库，如顺丰和平安科技是自己的题库
- 项目的积累
实战， 必须要做一个Java项目，因为你不做，对于你投递Java相关的岗位很吃亏，面试官可能没法问你相关问题，只能问你基础，但是这种Java指示大家掌握的时期都差不多，那为啥人家不找科班的去找你？他也不知道你自己项目实战如何
（ps：我觉得不要做这个什么电商和博客系统了，我觉得你可以练手，但是不要写在简历上了，这种项目我觉得面试官已经看腻了，最好做个比较有新意的，比如说我现在是做cv方向的，那我就做了一个目标检测+后台监控+视频流处理的项目，这样面试官觉得很有新意，把Java跟cv结合起来，如果各位想要，我也可以给各位贡献自己的源码）
五、学习路线以及个人准备的思路
我的技术博客
只针对小白来说，大佬也可以来指点一下
- Java
视频：
我觉得可以先把尚硅谷的Java基础看完，一定要对关键的知识点进行练习，比如说集合框架、Java8新特性等等 其实尚硅谷的一些案例大体看一下就行了，没必要练习，因为后面的框架会很好用，如果你在这里浪费时间确实得不偿失
书籍：
- Java核心卷
- 并发
视频：
主要看尚硅谷的的多线程视频首先有一个简单的了解与使用就可以了，之后如果需要进行提高，可以看书和看视频，视频的话，我推荐 - 黑马的[全面深入学习java并发编程]（https://www.bilibili.com/video/BV16J411h7Rd?from=search&seid=6747749983532175282）但是这个课程对于JUC的介绍确实很少， - [并发编程](https://www.bilibili.com/video/BV1vE411D7KE?from=search&seid=6747749983532175282)这个课程对于JUC讲解的比较好
书籍：
其实这一部分我更推荐看书 - 实战Java高并发程序设计 - Java并发编程之美 我是看了这两本书，有了基础了解，但是具体的还是要进行实战进行练习，我觉得并发这块实战+知识相结合
- JVM
视频：
我觉得Java的核心就是JVM，比如说垃圾回收、类加载等等 - 尚硅谷的[尚硅谷最新版宋红康JVM教程]（https://www.bilibili.com/video/BV1PJ411n7xZ?from=search&seid=10862637049186801576）但是这个课程对于JUC的介绍确实很少， - [并发编程](https://www.bilibili.com/video/BV1vE411D7KE?from=search&seid=6747749983532175282)这个课程对于JUC讲解的比较好
书籍：
其实这一部分我更推荐看书 - 实战Java高并发程序设计 - Java并发编程之美 我是看了这两本书，有了基础了解，但是具体的还是要进行实战进行练习，我觉得并发这块实战+知识相结合
- 计算计网络与操作系统
视频：
这边说实话，视频我确实没怎么看过，主要是以书籍为主
书籍：
- 图解HTTP与图解TCP - 计算机网络黑皮书 - 操作系统黑皮书
- 数据库
视频：
数据库这边我主要是学习了mysql的，其中mysql其实也是要努力练习的，我这边的话主要推荐[牛客网mysql练习](https://www.nowcoder.com/ta/sql)，视频的话，主要是推荐尚硅谷的视频，一个基础部分，一个提高部分 - [尚硅谷mysql视频](https://www.bilibili.com/video/BV12b411K7Zu?from=search&seid=4468081360617030606)
书籍：
- 高性能MySQL - 数据库索引与高性能 - 高性能SQL实战
- 框架部分
视频：
这边建议是一边实战一遍补充基础知识，我觉得可能效率更高 - [实战博客项目](https://www.bilibili.com/video/BV1r4411r7au?from=search&seid=11329217900108991393) - [尚硅谷SSM大全](https://www.bilibili.com/video/BV1uE411C7CW?from=search&seid=3659025257883092256)
书籍：
- SpringBoot实战派
六、自己的失败经历
在秋招期间，也是自己的能力不到位，遇到了很多的问题还有认识到了自己的缺陷，发现问题主要在于：
知识掌握的深度不够，很多知识点知识懂得皮毛，面试一问就知道你是在看面经
算法题深度不够，很多题目只知其一不知其二三，同时对于条件的改变会出现偏差
项目准备不够充分，与岗位契合度有一定偏差
B站一面挂，面了我接近两个小时，觉得是刷了kpi
作业帮，二面挂，估计是觉得我不是java吧
美的，一面挂，全程问我深度学习
跟谁学，感谢信
滴滴，应该是简历挂
深信服，没做
华为，放弃面试
人寿研发中心，不合格
个人的惨痛经历请看：https://www.nowcoder.com/discuss/544945?source_id=profile_create&channel=1009
只希望自己犯的错误，大家避免吧，今年实在是太难了。据说去年开发很容易，今年啥啥都难
七、面试询问的主要方面
面试的套路无非一下几个方面
- 自我介绍
- 项目介绍
- 算法
- 知识询问
- 反问
1. 自我介绍
其实我觉得自我介绍还是比较重要的，这个是面试官对你印象以及感兴趣的第一步，我觉得个人介绍更多的应该从你觉得你掌握比较好的地方介绍，比如说你有五个项目，最好有一个最突出的，而且个人介绍不要太长，要先入为主,就是在你的引导下，往这个方向走，这样你会占据主动权，尽可能避免在自我介绍中出现你没有掌握的地方
2. 项目介绍
项目介绍，如果你是面Java相关岗位，我的建议是尽量有一个项目支撑，这样就不会面临一个尴尬的境地，如果你的算法能力不是很强，可能项目这边可以给你拉回一点分数
项目介绍，如果你是非科班出身，而且又是cv方向，想转Java，那么我觉得你可以参考一下我的思路，做一个计算机视觉+Java相关的课题，这样，你的优势会很好的，我就是因为这个项目，在面试过程中，很大一部分时间都是在问我的项目里的东西，虽然Java占比少，但是会引起面试官的关注度，他会觉得你是怎么结合的？你的出发点在哪？你是如何克服cv与Java的矛盾的？所以你要是想做，现在就可以着手做了（ps：可以参考我做的项目，自吹自擂一下，o(╥﹏╥)o）
3. 算法
算法主要是leetcode+labuladong的公众号
leetcode刷个200道我觉得就够了，没必要刷太多，如果你能力够强，可以继续往后面做题
还有左神的视频课程也是很好的，我这边有课程，你可以私信我，我都可以无偿捐献
算法从现在开始就得保证，一天一刷了。不然明天秋招会更加吃亏的
4. 知识询问
这个就是我的面经了，这个就主要看你自己的知识积累和牛客的面经，然后变成自己的储备库了
我自己一共分为了八大内容：
- Java基础
- JVM
- 并发
- 计网+操作系统
- 数据库
- Redis
- 框架+SpringBoot
- 设计模式+算法
5.反问
我觉得反问要很有技巧，如果你想知道表现如何，你可以委婉的问一下面试官对你的态度如何？
还有很多反问，，比如说公司业务等等，还有你自己感兴趣的
八、自己整理的高频考点
8-1：Java高频
1.java基础-java特性
1-1：java特点
1-2：JVM\JRE\JDK\JIT
1-3：变量的初始化顺序
1-4：⾯向过程性能⽐⾯向对象⾼
1-5：持久化对象三种状态
2.java基础-面对对象(OOP)
2-1：面向对象的原则
2-2：Java类以及类的成员
2-2-1：属性
2-2-1-1：属性与局部变量的相同点、不同点
2-2-2：java基础-构造器
2-2-2-1：⼀个类的构造⽅法的作⽤是什么
2-2-2-2：构造⽅法有哪些特性？
2-2-2-3：构造方法可不可以被重写和重载
2-2-2-4：构造函数能用private修饰吗
2-3：面对对象三大特性
2-3-1：封装
2-3-1-1：封装的应用场景
2-3-2：继承
2-3-2-1：什么是继承
2-3-2-2：继承的应用场景
2-3-3：多态
2-3-3-1：多态的必要条件（实现方式、机制）
2-3-3-2：多态的好处
2-3-3-3：多态的例子
2-4：抽象
2-4-1：Java 抽象类可以有构造函数吗？作用是什么
2-4-2：Java 抽象类可以实现接口吗？ 它们需要实现所有的方法吗
2-4-3：Java 抽象类可以是 final 的吗
2-4-4：Java 抽象类可以有 static 方法吗
2-4-5：可以创建抽象类的实例吗（new 类）
2-4-6：抽象类必须有抽象方法吗
2-4-7：何时选用抽象类而不是接口
2-4-8：Java中的抽象方法是什么
2-4-9：Java抽象类中可以包含main方法吗
2-7：面对对象区别
2-7-1：接⼝和抽象类的区别
2-7-2：继承和接口区别
2-7-3：为什么要设计接口、抽象类还有实现类
2-8：面对对象应用场景
2-8-1：接口和抽象类的应用场景
2-.java基础-关键字
10-1：关键字
10-1: 通过反射访问private成员和方法，既然能访问为什么要private？
10-2：static关键字
10-2-1：static使用场景
10-2-2：静态⽅法和实例⽅法有何不同
10-2-3：静态变量和实例变量的区别？
10-2-4：static的应用
10-2-4-1：一个类创建了多个对象，如何保证只使用一个类属性
10-2-5：static方法可以访问非static方法或变量吗?
10-3：final关键字
10-3-1：final关键字使用场景
10-3-2：final, finally, finalize 的区别。
10-3-3：使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？
10-4：this关键字和super关键字
10-5：transient关键字
4.java基础-重载与重写
4-1：重载与重写
4-2：Java 中是否可以覆盖(override)一个 private 或者是 static 的方法？
5.java基础-值传递与引用传递
5-1：值传递与引用传递的概念
5-2：值传递与引用传递的实例举证
6.java基础-深拷贝与浅拷贝
6-1：深拷贝与浅拷贝
6-2：浅拷贝方法
6-3：深拷贝方法
6-4：深拷贝与浅拷贝的区别
6-5：赋值和浅拷贝的区别
7.java基础-equals与hashcode
7-1： == 与 equals
7-2：为什么要重写hashcode与equals
7-2-1：重写equals不重写hashcode会出现什么问题
7-2-2：为什么两个对象有相同的hashcode值，它们也不一定是相等的？
7-3：阿里关于hashcode和equals的处理规则
7-4：hashcode和equals源码写一下
8.java基础-i++与++i的问题
8-1：i++和++i的区别，及其线程安全问题
8-2：i++和++i是否为原子操作
8-3：如何实现i++和++i的原子性呢？
9.java基础-数据类型
9-1：八种数据类型是什么？
9-1-1：java为什么除了基本数据类型还要有引用数据类型
9-1-2：String为什么不是基本数据类型
9-1-3：引用类型有哪几种
9-2：数据类型的范围
9-2-1：为什么byte类型是-128~+127
9-3：自动拆装箱
9-3-1：为什么要有自动拆装箱
9-3-2：自动拆装箱的原理
9-3-3：自动拆装箱使用场景
9-3-4：自动拆装箱带来的问题
9-4：Integer缓存机制
9-4-1：int与Integer区别
9-5：String转出int型， 判断能不能转？ 如何转？
9-6：short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1+=1;有什么错?
11.java基础-各种集合家族
11-1：Collection集合框架
11-2：并发集合框架爱
11-2-1：并发集合出现的原因
12.Hashmap
12-1：hashmap的数据结构
12-2-1：扩容死循环问题
12-2-2：链表插入法
12-2-2-1：头插法
12-2-2-2：尾插法
12-2-3：红黑树的引入
12-2-3-1：HashMap为什么要树化?
12-2-3-2：hashmap树化门槛及作用
12-2-3-3：为什么JDK8时候引入了红黑树
12-2-3-4：为什么不把链表全部换为红黑树
12-2-3-5：为什么是使用红黑树而不是AVL树？
12-2-3-5：为什么不用二叉查找树代替，而选择红黑树
12-3-4：HashMap为什么可以插入空值?
12-4：JDK8中hashmap的改变
12-2：put操作
12-2-1：手写put方法
12-3：HashMap的get操作
12-3-1：手写get方法
12-3-2：hashmap的get和put操作的时间复杂度
12-4：hashmap的String类型如何计算hashcode的
12-5：hashmap源码部分
12-5-1：HashMap中(tab.length - 1) & hash作用
12-5-3：为什么默认初始化桶数组大小
12-5-4：hashmap为什么是2的次幂
12-6：hashmap扩容过程
12-6-1：什么时候扩容
12-6-2：reHash（重散列）过程
12-6-3：该容量如何变化
12-6-4：这种变化会带来什么问题
12-6-3：扩容的几个参数
12-6-3-1：HashMap 的 table 的容量如何确定
12-6-3-2：loadFactor 是什么
12-6-3-2-1：扩容因子为什么是0.75
12-6-6：数组扩容
12-6-7：为什么在JDK1.7的时候是先进行扩容后进行插入，而在JDK1.8的时候则是先插入后进行扩容的呢
12-6-8：JDK1.8链表转化为红黑树的阈值是8,而不是7或者不是20呢
12-6-6：插入一万个元素之后会不会扩容，扩容扩多少
12-7：hash函数
12-7-1：hash 的实现
12-7-1-2：为什么要用异或运算符？
12-7-2：哈希冲突的解决方法
12-7-3：一致性Hash算法
12-7-3-1：一致性hash和普通hash区别
12-8：扰动函数以及作用
12-9：hashmap线程问题
12-9-1：线程安全的Map
12-9-2：设计线程安全的map
12-10：hashmap应用
12-10-1：为什么hashmap中String、integer包装类适合作为key
12-10-2：如果想要一个key对应多个Value的话，怎么设计Map
12-10-3：创建一个对象HashMap<Integer,Integer> map=new HashMap<>先put(10),然后get(new Long(10))结果是多少？
12-10-4：使用final static修饰集合hashmap会产生什么影响
12-11：JDK的hashmap与Redis的hashmap的区别
13.ConcurrentHashMap数据结构
13-1：ConcurrentHashMap的底层实现
13-1-1：为何会出现ConcurrenHashMap?
13-1-2：为什么ConcurrentHashMap（hashtable）为何不支持null键和null值
13-1-3：分段锁原理
13-1-4：为什么要使用内置锁synchronized来代替重入锁 ReentrantLock？
13-2：ConcurrentHashMap的put操作
13-2-1：手写ConcurrentHashMap的put操作
13-2-2：hashmap与ConcurrentHashMap中put的区别
13-3：ConcurrentHashMap的get操作
13-3-1：手写ConcurrentHashMap的get操作
13-4：ConcurrentHashMap扩容机制
13-4-1：什么时候会发生扩容机制
13-4-2：hashmap与ConcurrentHashMap中扩容的区别
13-5：ConcurrentHashMap读写操作的锁
13-6：为什么 ConcurrentHashMap 比 HashTable 效率要高？
13-7：ConcurrentHashMap 的并发度是什么？
14.TreeMap
14-1：TreeMap数据结构
14-2：TreeMap使用场景
15.LinkedHashmap
15-1：LinkedHashmap数据结构
16.HashTable
16-1：HashTable数据结构
17.ArrayLlist
17-1：ArrayList数据结构
17-1-1：数组(Array)和列表(ArrayList)有什么区别？
17-2：ArrayList扩容机制
17-2-1：ArrayList的add操作
17-2-2：Arraylist初始大小以及扩容大小
17-3：ArrayList线程安全
17-3-1：那如何解决ArrayList线程不安全问题呢？
18.vector
18-1：vector数据结构
18-2：扩容机制
18-3：Vector是保证线程安全的
19.linkedlist
19-1：linkedlist数据结构
20.set
20-1：set数据结构
21.hashset
21-1：HashSet数据结构
21-2：hashSet的内存泄漏
21-3：HashSet线程安全
21-3-1：HashSet如何保证线程安全
22.TreeSet
22-1：TreeSet数据结构
23.LinkedHashSet
23-1：LinkedHashSet数据结构
24.线程安全/非线程安全的集合
25.java基础-集合-集合大比较
25-1：set和list、map的区别
25-2：arraylist、linkedlist区别和适用场景
25-3：vector、Arraylist区别和适用场景
25-4：HashMap、Treemap、linkedHashMap区别和适用场景
25-5：HashTable、Hashmap区别和适用场景
25-6： ConcurrentHashMap、Hashmap区别和适用场景
25-7： Hashset、Hashmap区别和适用场景
25-8：treeset、hashset区别和适用场景
26.Collections
26-1：collection与collections的区别
26-2：Collections有哪些静态方法
26-3：Comparable和Comparator区别
27.IO
27-1：IO流
27-1-1：为何还要有字符流
27-1-2：字节流和字符流区别
27-2：IO读取
27-2-1：IO读取方法
27-2-2：将c盘的文件复制到d盘
27-3：BIO\NIO\AIO
27-3-1：BIO\NIO\AIO定义
27-3-2：BIO与NIO的区别
27-4：IO模型
27-4-1：IO多路复用
27-4-2：IO多路复用实现方式
27-4-2-1：三种实现方式以及优缺点
27-4-2-2：三种常用的实现方式区别
27-5：同步、异步与阻塞、非阻塞
27-5-1：IO发生时涉及的对象和步骤（23期修改）
27-5-2：同步、异步与阻塞、非阻塞区别
28.反射
28-1：反射的概念
28-1-1：反射会导致性能问题呢
28-1-1-1：如何避免反射导致的性能问题
28-1-2：哪些类不能反射
28-1-3：反射优缺点
28-1-4：反射的应用场景
34-2：Class类的作用
34-2-1：获取class对象方法
34-2-2：Class.forName和classloader.loadClass的区别
28-3：反射应用
28-3-1：反射实例
28-3-2：反射调用类的私有方法
29.注解
29-1：元注解以及分类
29-2：Java常用注解
30.泛型
30-1：什么是泛型
30-2：编译器如何处理泛型
30-2-1：为什么Java要用这种编译器
30-3: 什么是类型擦除
30-3-1：类型擦除过程
30-4：泛型带来的问题
30-5：泛型应用
30-5-1：List泛型和原始类型List之间的区别?
30-5-2：List泛型和原始类型List泛型之间的区别?
30-5-3:子类继承父类的public可以写成private吗
30-5-4：多态时是否会出现类型擦除
31.异常
31-1：异常的分类
31-1-1：Error和Exception的区别
31-2：Java中的两种异常类型是什么
31-2-1：他们有什么区别
31-2-2：异常链
31-3：什么是OOM？常见有哪些OOM
31-4：try、catch、finally执行顺序
31-4-1：不带return返回顺序
31-4-1：带return返回顺序
32.String
32-1：string数据结构
32-1-1：String为什么是final的？
32-1-2：String的内部属性
32-1-3：String的常用方法
32-1-4：subString原理
32-1-5：String长度有限制的
32-2：String str = new String("abc");创建了几个对象
32-2-1：String str="abc",堆和常量池中的情况
32-2-2：String str = new String("abc");堆和常量池中的情况
32-3：String的==与equals问题
32-3-1：两个st1 = "abc"相等问题
32-3-2：一个创建对象，一个str1=“abc”
32-3-3：一个a+b+c，一个abc
32-3-3-1：常量优化机制
32-3-4：一个str1+c，一个abc
32-3-5：两个new String对象
32-3：拼接方式
32-4: String、StringBuffer和StringBuilder区别
32-4-1：StringBuffer如何实现线程安全
32-4-2：处理数据量较大的字符串用string还是stringbuilder，为什么
32-4-3：为什么StringBuffer和StringBuilder比String更快（不变性）
32-5：应用
32-5-1：如何把一段逗号分割的字符串转换成一个数组?
32-5-2：String 和 char[] 数组谁更适合存密码
33.枚举
33-1：enum线程安全
33-2: switch 是否可用于String类型的判断
34.时间类
34-1：SimpDateFormat是线程不安全的类，如何改为线程安全
35.Object类
35-1：Object类有哪些方法
35-1-1：XX.toString和String.valueOf()
35-1-1：为什么操作线程方***在Object对象中
36.序列化与反序列化
36-1：Java序列化与反序列化是什么
36-2：为什么需要序列化与反序列化
36-3：java对象如何实现序列化与反序列化
36-3-1：如何实现序列化
36-2-1-1：externalizable和Serializable的区别
36-2-1-2: 什么是serialVersionUID
36-2-1-3：序列化协议有哪些
36-2-1-4：该接口并没有方法和字段，为什么只有实现了该接口的类的对象才能被序列化呢？
36-3-2：java对象如何实现反序列化
36-4：哪些不会被序列化
36-5：序列化和反序列化应用场景
37.JDK8新特性
38.字符集
38-1：字符集种类
38-2：Unicode字符集
38-2-1：有了Unicode为啥还需要UTF-8
38-2-2：UTF-8编码原理
39.创建对象
8-2：并发高频
1.进程
1-1：什么是进程
1-2：进程的状态
1-2-1：进程的状态变迁
1-3：什么是进程的控制结构
1-3-1：什么是PCB
1-3-2：PCB 具体包含什么信息呢？
1-3-3：每个 PCB 是如何组织的呢？
1-4：进程的控制
1-5：进程间通信
1-5-1：管道
1-5-1-1：管道分类
1-5-2：消息队列
1-5-2-1：消息队列的不足
1-5-3：共享内存
1-5-4：信号量
1-5-4-1：控制信号量的方式
1-5-4-2：两个进程互斥访问共享内存流程
1-5-4-3：信号量来实现多进程同步的方式
1-5-5：信号
1-5-5-1：用户进程对信号的处理方式
1-5-6：Socket
1-6：进程的内存结构
2.线程
2-1：线程概念
2-1-1：为什么使用线程
2-1-2：线程的优缺点
2-2：三种线程的实现方式
2-2-1：用户线程和内核线程的对应关系
2-2-2：用户线程如何理解？
2-2-2-1：用户线程存在什么优势和缺陷？
2-2-3：内核线程如何理解？
2-2-3-1：内核线程存在什么优势和缺陷
2-2-4：轻量级进程如何理解
2-2-5： LWP 与用户线程的对应关系
2-3：线程之间通信方式
2-3-1：同步
2-3-2：while轮询的方式
2-3-3：wait/notify机制
2-3-4：管道通信
3.线程与进程的区别
3-1：进程切换与线程切换的区别
3-2：为什么进程花销比线程花销大
4. 上下文切换
4-1：什么是上下⽂切换?
4-2：CPU 上下文切换
4-3：进程的上下文
4-3-1：进程上下文概念
4-3-2：进程的上下文切换到底是切换什么呢？
4-3-3：发生进程上下文切换有哪些场景？
4-4：线程上下文
5.调度
5-1：什么是调度
5-2：什么时候会发生调度
5-3：调度原则
5-4：进程调度算法
6.互斥与同步
6-1：互斥概念
6-1-1：临界区
6-2：同步概念
6-2-1：同步的原理
6-2-1：线程同步的方式
6-2-2：同步方法和同步代码块的区别是什么
6-2-3：在监视器内部，是如何做线程同步的？
6-3：同步与互斥的区别
6-3-1：互斥与同步实现
7.生产者与消费者问题（同步问题）
7-1：java中几种解决同步问题的方式
8.并发级别（并行和并发）
8-1：并行与并发概念
9.并发特性
5.多线程
5-1：为什么要使⽤多线程呢
5-1-1：使⽤多线程可能带来什么问题?
5-2：多线程公共用一个数据注意什么
5-2-1：如何确保 N 个线程可以访问 N 个资源同时又不导致死锁？
5-2-2：单cpu上多线程效率和单线程比如何
6.线程的基本操作
6-1：说说 sleep() ⽅法和 wait() ⽅法区别和共同点?
6-2：yield join notify notifyAll
6-3：为什么我们调⽤ start() ⽅法时会执⾏ run() ⽅法，为什么我们不能直接调⽤run() ⽅法
6-4：中断线程方法（36期）
6-5：一般线程和守护线程以及两者区别
12.创建线程
12-1：创建线程的方式
12-1-1：实现Runnable接⼝和Callable接⼝的区别
12-1-2：实现 Runnable 接口比继承 Thread 类所具有的优势
12-1-3：run()方法和start()方法的区别
12-2：创建线程的对比
13.线程安全
13-1：什么是线程安全
13-1-1：举例说明线程不安全
13-2：线程安全的方式
14.synchronized关键字
10-1：synchronized关键字
10-2：JDK1.6优化有哪些？
10-3：底层原理
10-3-1：monitor基本原理
10-4：synchronized的优势
10-5：synchronized锁的膨胀（升级）过程
10-6：那如何判断共享数据不会被线程竞争？
10-7：synchronized将线程的并行处理转为串行处理，有什么缺点
10-8：使用Synchronized关键字需要注意什么
10-9：synchronized在内存层面，是如何实现加锁和释放锁的？
10-10：synchronized关键字，是怎么保证线程安全的呢？
15.volatile关键字
15-1：基本原理
15-1-1：缓存一致性协议
15-1-2：内存屏障
15-1-2-1：volatile中的内存屏障
15-2：为什么要是用volatile关键字
15-3：volatile的作用
15-4：原子性
15-4-1：volatile为什么不保证原子性吗
15-4-2：怎么保证输出结果是20000呢
15-5-3：volatile都不保证原子性，为啥我们还要用它？
15-6：安全性
15-7：重排
15-7-1：为什么其他线程能感知到变量更新
15-7-2：为什么要重排
15-7-3： 有哪几种重排
15-7-4：举例说一下指令重排
15-8：happen-before原则是什么
15-9：volatile的典型应用场景
16.synchronized与其他的区别
16-1：谈谈 synchronized和ReentrantLock 的区别
16-2：Lock和synchronized的区别
16-3：synchronized 关键字和 volatile 关键字的区别
17.线程池--死锁
17-1：使⽤线程池的好处
17-2：常规实现线程池方法
17-3：线程池增长策略
17-3-1：线程池的核心线程数和最大线程数
17-4：线程池拒绝策略
17-5：线程池参数
17-6：线程池处理流程
17-7：设计线程池
17-7-1：如何设计一个线程池
17-8：死亡问题
17-8-1：单一线程池中线程死亡该怎么办
17-8-2：如何防止线程池线程死掉
17-9：线程池的风险
17-9-1：死锁
17-9-1-1：什么是线程死锁
17-9-1-2：产生死锁的条件
17-9-1-3：如何解决线程死锁问题
17-10：线程池单例问题
18.锁
18-1：锁
18-2：乐观锁与悲观锁
18-2-1：两种锁的使用场景
18-2-2：乐观锁常见的两种实现方式
18-2-3：乐观锁的缺点
18-3：自旋锁
18-3-1：自旋锁的优缺点
18-3-2：自旋锁的升级——自适应自旋
18-3-3：自旋锁使用场景
18-4：可重入锁（递归锁）
18-4-1：可重入锁使用场景
18-4-2：可重入锁如果加了两把，但是只释放了一把会出现什么问题？
18-4-3：如果只加了一把锁，释放两次会出现什么问题？
18-5：读写锁
18-6：公平锁与非公平锁
18-6-1：公平锁与非公平锁优缺点
18-6-2：公平锁与非公平锁使用场景
18-7：共享锁
18-7-1：共享锁使用场景
18-8：独占锁
18-8-1：独占锁使用场景
18-9：重量级锁
18-9-1：重量级锁使用场景
18-10：轻量级锁
18-10-1：轻量级锁优缺点
18-11：偏向锁
18-11-1：偏向锁优缺点
18-12：分段锁
18-13：互斥锁
18-14：同步锁
18-15：死锁
18-16：锁粗化
18-17：锁消除
18-18：提高锁性能的方法
19.ThreadLocal
19-1：什么是ThreadLocal，优势在哪里
19-2：ThreadLocal的实现原理
19-3：ThreadLocal内存泄露问题
19-3-1：ThreadLocal如何防止内存泄漏？
20.线程变量绑定
21.无锁-CAS、Atomic
21-1：CAS
21-1-1：CAS使用时存在的问题以及解决方案
21-1-1-1：CAS的ABA问题
21-2：CAS原理
21-2：原子类原理
21-1-1：为什么要使用原子类
21-1-2：原子类的作用？
21-4：i++自增操作不是原子性的，如何决绝原子性问题
21-5：基本数据类型原子类的优势
21-6：为什么是unsafe
26-2：Unsafe为什么是不安全的？
26-3：Unsafe的实例怎么获取？
26-4：讲一讲Unsafe中的CAS操作？
26-5：unsafe的阻塞/唤醒操作？
23.AQS（队列同步器）
23-1：对AQS原理分析
23-2：AQS 对资源的共享⽅式
23-3：AQS 组件
23-4：AQS应用场景
24.并发容器
24-1：JDK 提供的并发容器总结
24-2：CopyOnWriteArrayList 是如何做到的？
24-3：BlockingQueue
24-3-1：什么是阻塞队列
24-3-2：阻塞队列的常用类
24-3-3：手写堵塞队列
25.快速失败与安全失败
8-3：JVM高频
1.JVM
1-1：JVM1.8新特性
1-2：JDK1.8默认垃圾回收器
2.类加载
1-1：类的生命周期
1-2：类的加载过程（37期）
1-2-1：符号引用于直接饮用
1-3：类加载机制
1-4：知道哪些类加载器?
1-4-1：类加载器之间的关系
1-5：创建并使用自定义类加载器
1-5：双亲委派模型流程
1-5-1：双亲委派模型带来了什么好处呢？
1-5-2：如果我们不想⽤双亲委派模型怎么办？
1-5-3：自己写一个类能不能被加载？
1-5-4：如何破坏双亲委派机制
3.垃圾回收
3-1：什么是GC
3-1-1：垃圾回收的优点
3-1-2：什么样的对象需要回收
3-1-3：垃圾回收器可以马上回收内存吗？
3-1-4：有什么办法主动通知虚拟机进行垃圾回收？
3-2：垃圾回收器的基本原理是什么？
3-3：如何判断对象已经死亡？
3-3-1：可作为GC Roots的对象？
3-3-2：不可达的对象是否非死不可
3-4：如何判断一个类是无用的类
3-5：如何判断一个常量是废弃常量？
3-6：如何减少 GC 的次数
3-7：垃圾回收算法
3-8：垃圾回收器
3-8-1：Serial收集器
3-8-2：ParNew收集器
3-8-3：Parallel Scavenge收集器
3-8-4：Serial Old收集器
3-8-5：Parallel Old收集器
3-8-6：CMS收集器
3-8-6-1：产生 concurrent mode failure 真正的原因
3-8-6-2：CMS 出现FullGC的原因
3-8-6-3：cms怎么解决内存碎片的问题
3-8-6-4：CMS GC发生concurrent mode failure时的full GC为什么是单线程的?
3-8-7：G1收集器
3-8-8：CMS与G1区别
3-8-9：吞吐有限和响应有限的垃圾收集器如何选择
3-9：为什么要分代回收？分代回收背后的思想？
3-9-1：young gc、old gc、full gc、mixed gc区别
3-9-1-1：新生代的 GC 如何避免全堆扫描？
3-9-1-1：young gc 触发条件是什么？
3-9-1-1-1：TLAB你了解多少？
3-9-1-1-2：PLAB你了解多少？
3-9-1-2：full gc 触发条件有哪些？
3-10：为什么有些新老年代的收集器不能组合使用比如 ParNew 和 Parallel Old？
3-10：为什么新生代都是复制算法，老年代都是标记整理算法
- JVM内存模型（堆栈五大分区）
4-1：堆的分区
4-1-1：分区的目的
4-1-2：Minor GC与Full GC分别什么时候发生？
4-1-3：Minor Gc和Full GC 有什么不同呢？
4-1-5：年轻代
4-1-5-1：为什么会有年轻代
4-1-5-2：年轻代中的GC
6-5：为什么是8：1：1
4-1-6：老年代
4-1-7：持久代
4-1-8：对象在堆内存移动
4-1-8-1：如何判断发生GC时对象在堆内存移动呢？
4-1-9：Java中对象并不是都在堆上分配内存的
4-2：栈
4-1-1：栈的实现
4-1-2：栈堆存放什么东西
4-1-2：什么是栈
4-1-3：栈帧
4-1-3-1：栈帧结构
4-1-4：虚拟机栈和本地⽅法栈为什么是私有的?
4-3：堆与栈的区别
4-3-1：
4-4：程序计数器
4-4-1：为什么要有程序计数器（作用）
4-4-2：程序计数器为什么是私有的?
4-4：元空间
4-4-1：Java 8的metaspace (元空间)
4-4-2：为什么要进行元空间代替持久代呢? - Java内存结构（JMM）
5-1：为什么需要Java内存模型？
5-1-1：什么是Java内存模型？
5-1-2：Java内存模型的两大内存是啥？
5-1-3：内存如何工作
5-2：什么是JMM - Java对象的创建过程（对象头等概念）
6-1：内存分配的两种⽅式选择
6-2：虚拟机如何保证线程安全
6-3：对象的访问定位有哪两种⽅式?
6-3-1：访问定位两种方式的优缺点 - 对象头
- 对象分配规则
- 内存泄露与内存溢出
8-1：什么是内存泄漏
8-1-1：如何检测内存泄***r>8-2：什么是内存溢出
8-2-2：手写出现内存溢出的情形
8-3：内存溢出，内存泄漏区别
8-4：如何避免内存泄露、溢出
8-5：内存结构的溢出与泄***r>8-5-1：溢出
8-5-1-1：溢出例子
8-5-2：泄露 - 调优工具
3-2：强、软、弱、虚引用
10-1:虚引用与软引用和弱引用的一个区别- JVM进程有哪些线程启动? (拼多多)
- jvm启动模式之client 与server
- 简述JVM中静态分派和动态分派(引申:重载和重写)
8-4：计网与操作系统
1.各层协议
1-1：OSI与TCP/IP各层的结构与功能,都有哪些协议?
1-2：⽹络层与数据链路层有什么关系呢？
1-3：网络层的路由算法
1.Get与Post
1-1：get与post的区别
1-2：后台获取前端数据方法
1-3：如何通过GET方式上传压缩包
2.报文结构与状态码
2-1：状态码
2-2：HTTP请求组成
3.计算机网络-HTTP-HTTP的1.0-3.0
3-1：HTTP-1.0
3-1-1：HTTP-1.0优缺点
3-1-2：Http为什么是无连接和无状态的
3-2：HTTP-1.1
3-2-1：HTTP/1.1相对于HTTP1.0改善
3-2-2：HTTP1.1缺点
3-2-3：HTTP⻓连接,短连接(也是TCP连接,短连接)
3-3：HTTP-2
3-3-1：HTTP/2 做了什么优化
3-3-2：HTTP/2有哪些缺陷
3-4：HTTP-3
3-4-1：HTTP/3做了哪些优化
3-5：http工作流程
3-6：一个 TCP 连接后是否会在一个 HTTP 请求完成后断开？什么情况下会断开？
4.计算机网络-HTTP与HTTPs前世今生
4-1：什么是HTTPS
4-2：HTTPS 解决了 HTTP 的哪些问题？（为什么要HTTPS）
4-2-1：加密算法
4-2-1-1：Https对称加解密的过程
4-2-1-2：Https非对称加密过程
4-2-1：数字证书认证机构的流程
4-3：HTTP与HTTPS建立请求过程
4-3-1：HTTP 请求过程
4-3-2：HTTPS 请求过程（加密过程）
4-3-2-1：SSL/TLS握⼿
4-3-3：HTTP与HTTPS区别
4-3-4：为何不所有的网站都使用HTTPS
5.各种协议的端口号
6.拆包粘包
6-1：什么是TCP粘包？
6-2：粘包的原因
6-3：粘包解决方案
6-4：UDP会不会产生粘包问题呢？
6-5：HTTP拆包粘包
7.计算机网络-HTTP-Cookie与Session
7-1：Cookie 和 Session 的区别
8.计算机网络-HTTP-Cookie
8-1：Cookie作用
8-2：HTTP是不保存状态的协议,如何保存⽤户状态
8-3：Cookie 被禁⽤怎么办
8-3-1：cookie被禁用了，session还能用么
8-4：cookie如何放置攻击
9.计算机网络-HTTP-Session
9-1：Session用户登录状态过程
9-2：如何保存session
9-3：如何实现 Session 跟踪呢？
9-4：Session机制（多个session如何识别）
10.计算机网络-HTTP-token
10-1：token的验证流程
10-2：token和cookie实现的区别
11.计算机网络-HTTP-url/uri
11-1：URI和URL的区别是什么?
12.计算机网络-综合应用-输入网址
12-1：输入网址过程
12-2：为什么域名要分级设计
12-3：重定向原因
15.TCP的三次握手
15-1：TCP三次握手流程
15-2：TCP为什么要三次握⼿
15-3：TCP为什么SYN
15-4：TCP除了SYN，为什么还要 ACK
15-5：什么是 SYN 攻击？如何避免 SYN 攻击？
15-5：如何对三次握手进行性能优化
15-6：如何绕过三次握手发送数据
15-7：TCP Fast Open的过程
15-8：为什么需要 TCP 协议？
15-9：什么是 TCP 连接？
15-10：如何唯一确定一个 TCP 连接呢？
15-11：有一个 IP 的服务器监听了一个端口，它的 TCP 的最大连接数是多少？
15-12：服务端最大并发 TCP 连接数远不能达到理论上限
15-15：为什么客户端和服务端的初始序列号 ISN 是不相同的？
15-16：什么是Mss
15-17：既然 IP 层会分片，为什么 TCP 层还需要 MSS 呢？
16.TCP的四次挥手
16-1：TCP四次挥手流程
16-2：TCP为什么要四次挥手
16-3：TCP第四次挥手后会理解断开呢？
16-3：如何对四次挥手进行优化
16-4：为什么TIME_WAIT 等待的时间是 2MSL？
16-5：为什么需要TIME_WAIT状态？（已经主动关闭连接了为啥还要保持资源一段时间呢？）
16-6：TIME_WAIT 过多有什么危害？
16-7：如何优化 TIME_WAIT？
16-8：如果已经建⽴了连接，但是客户端突然出现故障了怎么办？
17.TCP传输数据优化方案
17-1：TCP传输数据优化
18.TCP与UDP/IP比较
18-1：TCP与UDP区别
18-2：TCP 和 UDP 应用场景
18-3：TCP与IP的区别
19.TCP
19-1：TCP
19-1-1：为什么TCP面向流
19-2：TCP首部
19-2：TCP作用
19-3：TCP 数据包的大小
19-4：TCP 数据包的编号（SEQ）
19-5：TCP 数据包的组装
19-6：TCP首部组成
20.TCP/UDP如何保证可靠传输方式
20-1：TCP如何保证稳定传输
20-2：UDP如何做可靠传输
21.重传机制
21-1：常见的重传机制
21-2：超时重传
21-3：什么时候会发生超时重传
21-4：超时重传存在的问题
21-5：快速重传
21-6：快速重传的问题
21-7：SACK方法
21-8：D-SACK
21-9：D-SACK好处
22.滑动窗口与流量控制
22-1：引入窗口概念的原因
22-2：什么是窗口
22-3：窗口大小由哪一方决定？
22-4：发送方的窗口
22-5：流量控制
22-6：流量控制的过程
22-9：TCP 是如何解决窗口关闭时，潜在的死锁现象呢？
23.拥塞控制
23-1：为什么要有拥塞控制呀，不是有流量控制了吗？
23-2：什么是拥塞控制
23-3：什么是拥塞窗口？和发送窗口有什么关系呢？
23-4：那么怎么知道当前网络是否出现了拥塞呢？
23-5：拥塞控制算法
23-6：那慢启动涨到什么时候是个头呢？
23-7：重传机制何时结束
24.ARQ协议
24-1：什么是ARQ协议
24-2：什么是停⽌等待ARQ协议
24-3: 什么是连续ARQ协议
25.Socket
25-1： TCP 应该如何 Socket 编程？
------操作系统--------------------------------------------
1.内存管理-虚拟内存
1-1：什么是虚拟地址
1-2：操作系统是如何管理虚拟地址与物理地址之间的关系？
1-3：什么是虚拟内存
1-3-1：虚拟内存的优缺点
1-3-2：为什么虚拟内存可以大于物理内存
2.内存管理-内存分段
2-1：什么是内存分段
2-2：分段机制下，虚拟地址和物理地址是如何映射的？
2-3：访问某段偏移量xxx的虚拟地址
2-4：内存分段缺陷
2-5：如何解决内存分段的缺陷
- 内存管理-内存分页
3-1：为什么有内存分页（内存分页定义）
3-2：分页是怎么解决分段的内存碎片、内存交换效率低的问题？
3-3：分页机制下，虚拟地址和物理地址是如何映射的？
3-4：简单的分页有什么缺陷吗？
3-5：简单的分页缺陷的解决方案
3-6：分了二级表，内存不是变大了呢
3-7：为什么不分级的页表就做不到这样节约内存呢？
3-8：多级页表的缺陷以及解决方案 - 内存管理-段页式内存管理
4-1：什么是段页式内存管理
4-2：段页式内存管理实现的方式 - 内存管理-linux内存管理
5-1：Linux 操作系统采用了哪种方式来管理内存
5-2：Linux 的虚拟地址空间是如何分布的？
5-3：内核空间与用户空间的区别
5-4：用户空间分布 - 内存管理-页面置换算法
6-1：页面置换算法
6-2：⻚⾯置换算法的作⽤?
6-3：手写LRU缓存 - 磁盘调度算法
- 文件系统组成
7-1：什么是文件系统 - 虚拟文件系统
- 文件的使用
- 文件的存储
- 空闲空间管理
- 文件系统的结构
- 目录的存储
- 软链接和硬链接
- 页面置换算法
8-5：数据库
1.MySQL
1-1：为什么要使用数据库
1-2: 什么是SQL？
1-3：什么是MySQL?
2. 关系型数据库与非关系型数据库
2-1：非关系型数据库和关系型数据库定义
2-2：关系型数据库优缺点
2-3：非关系型数据库优缺点
2-4：非关系型数据库和关系型数据库区别
3.三大范式
3-1：数据库三大范式是什么
3-2：三大范式举例
4.数据库的数据类型
4-1：mysql的数据类型
4-2：varchar与char的区别
4-2-1：varchar(50)中50的涵义
4-3：int(20)中20的涵义
4-4：FLOAT和DOUBLE的区别是什么？
4-5：MySQL INT和CHAR隐式类型转换需要注意什么？
5.SQL生命周期
6.MySQL预编译
6-1：预编译出现的原因
6-2：预编译的好处
7.SQL注入
7-1：SQL注入简介
7-2：SQL注入攻击实例
7-3：SQL注入解决方案
8.sql编写
8-0：SQL的分类
8-1：有什么查询
8-1-1：基础查询
8-1-4：子查询
8-1-4-1：子查询的三种情况
8-1-6：多表查询
8-1-6-1：笛卡尔积问题
8-1-6-2：笛卡尔积的解决方案
8-1-6-2-1：五种关联（连接）查询
5. 全连接(FULL JOIN)
8-2：常见函数
8-2-1：单行函数
8-2-3：聚合函数
8-3：关键字/语句
8-3-1：truncate、 delete区别
8-3-2：mysql的having用法
8-3-3：mysql中 in 和 exists 区别
8-3-4：WHERE子句和HAVING子句的执行速度
8-3-5：groupby和having的区别
8-3-6：UNION与UNION ALL的区别？
8-3-7：count(*)、count(1)、count(column)的区别
8-3-8：MySQL，左连接中on和where的区别
8-4：增删改查（CURD）--日志
8-4-1：一条sql执行过程
8-4-2：一条sql更新/删除/增加语句时怎么执行的
8-4-2-1：日志由来
8-4-2-1-1：什么是binlog
8-4-2-1-1-1：binlog一般用来做什么
8-4-2-1-1-2：MySQL的binlog有几种录入格式
8-4-2-1-2：redo log
8-4-2-1-3：bin log和redo log比较
8-4-2-1-3-1：我写其中的某一个log，失败了，那会怎么办？
8-4-2-1-4：两阶段提交意义
8-4-2-1-4-1：MySQL如何保证redo log和binlog的数据是一致的
8-4-2-1-4-2：如果整个数据库的数据都被删除了，那我可以用redo log的记录来恢复吗？
8-4-3：一条sql查询语句时怎么执行的
8-4-3-1：mysql有关权限的表都有哪几个
8-4-4：MySQL查询字段区不区分大小写？
8-4-4-1：如何解决需要区分英文大小写的场景
8-5：常见约束
8-5-1：字段为什么要求定义为not null?
8-6：键
8-6-1：超键、候选键、主键、外键分别是什么？
8-6-2：为什么用自增列作为主键
8-6-2-1：主键使用自增ID还是UUID?
8-6-2-1：为什么MySQL不推荐使用uuid或者雪花id作为主键？
8-6-2-2：使用自增id的缺点
8-6-2-3：数据库主键自增怎么获取主键值
8-6-3：为什么要尽量设定一个主键?
8-7：视图
8-8：存储过程
8-8-1：存储过程有哪些优缺点？
8-9：触发器
8-9-1：触发器的使用场景有哪些？
8-10：窗口函数
8-10-1：什么是窗口函数
8-10-2：窗口函数的定义
8-11：sql实战
8-11-1：去重重复数据
8-11-2：MySQL 如何高效率随机获取N条数据？
9.事务
9-1：什么是事务
9-2：数据库事务特性
9-2-1：ACID靠什么保证的(底层原理)
9-2-1-1：什么是undo log
9-2-1-1-1：Undo Log缺陷如何解决？
9-2-1-2：Java如何保证原子性
9-2-1-3：数据库崩溃时事务的恢复机制
9-3：在并发环境下,事务会发生哪些问题?
9-3-1：不可重复读和幻读的区别
9-3-2：如何解决幻读
9-4：如何解决事务并发问题
9-4-1：四大隔离级别
9-4-1-1：隔离级别的原理
9-4-1-1-1：为什么要有事物隔离级别
9-4-1-2：MySQL 中RC（读已提交）和RR（可重复读）隔离级别的区别
9-4-1-3：隔离级别用来做什么
9-5：如何手动处理事务
9-6：事务与日志
9-6-1：日志种类
9-6-2：事务是如何通过日志来实现的
10.引擎
10-1：MySQL存储引擎MyISAM与InnoDB区别
10-2：InnoDB引擎的4大特性
10-3：MyISAM和InnoDB存储引擎使用的锁
10-4：InnoDB存储引擎的锁的算法
11.锁
11-1：隔离级别与锁的关系
11-2：mysql锁的种类
11-2-1：共享/排它锁(Shared and Exclusive Locks)
11-2-2：意向锁(Intention Locks)
11-2-2-1：意向锁分类
11-2-3：记录锁(Record Locks)
11-2-4：间隙锁(Gap Locks)
11-2-5：临键锁(Next-key Locks)
11-2-6：插入意向锁(Insert Intention Locks)
11-2-7：自增锁(Auto-inc Locks)
11-3：行锁和表锁
11-3-1:表级锁
11-3-2：行级锁
11-4：悲观锁与乐观锁
11-4-1：悲观锁
11-4-2：乐观锁
11-4-2-1：数据版本
11-5：数据库死锁的预防与解除
11-6：锁类型
11-7：多版本并发控制MVCC
11-7-1：哪些读操作是快照读？哪些操作又是当前读呢？
11-7-2：为什么将 插入/更新/删除 操作，都归为当前读
11-8：加锁过程
12.索引
12-1：主键与索引的区别
12-2：索引的分类
12-2-1：各种索引场景
12-2-2：联合索引
12-2-2-1：联合索引失效的条件
12-2-2-2：单列索引和联合索引区别
12-2-3：覆盖索引
12-2-4：主键索引和普通索引的工作原理
12-3：mysql索引的结构
12-3-1：B+树与其他
12-3-1-1：B+树比B树的优势
12-3-1-1-1：B树
12-3-1-1-2：B+树
12-3-1-2：B+树与红黑树比较
12-3-1-3：B+树与hash索引比较
12-3-2：聚簇索引与非聚簇索引概念
12-3-2-1：聚簇索引的优缺点
12-3-2-2：非聚簇索引的优缺点
12-4：索引
12-4-1：为什么要用索引（优点）
12-4-2：索引这么多优点，为什么不对表中的每一个列创建一个索引呢？（缺点）
12-4-3：创建索引原则（使用场景）：
12-4-3：最左前缀原则内部原理
12-4-4：创建索引的注意事项
12-4-5：索引失效
12-4-6：为什么索引能够提高查询速度
12-4-7：创建索引的三种方式
12-5：索引叶子节点存放
12-5-1：索引叶子节点为什么不直接保存的记录地址而要存主键键值
13.优化方案
13-1：explain（优化）
13-1-1：explain应用场景
13-1-2：如何使用explain
13-1-3：explain主要包含的信息
13-1-3-0：主要包含信息
21-4-1：id
21-4-2：select_type
13-2：为什么要优化
13-3：数据库的优化（如果mysql数据过多，如何进行处理）
13-4：索引优化
13-5：查询优化
13-6：慢查询优化
13-7：创建时优化
13-8：一条SQL语句执行得很慢的原因有哪些
13-8-1：为什么数据库会选错了索引
13-9：分页查询优化
14.慢查询
15.主从复制
15-1：什么是主从复制
15-2：主从复制的作用（好处，或者说为什么要做主从）：
15-3：主从复制的原理（重中之重，面试必问）
15-4：主从复制的几种方式
16.阻塞
17.数据库池与JDBC
17-1：什么是数据库连接池？
17-1-1：数据库连接池种类
17-1-2：传统的连接机制与数据库连接池的运行机制区别
17-1-3：说说数据库连接池工作原理
17-1-4：实现方案？
17-1-5：数据库连接池最小连接数和最大连接
17-1-5-1：最小连接数和最大连接区别
17-1-5-2：最小连接数和最大连接数的设置要考虑到以下几个因素
17-2：JDBC
17-2-1：JDBC数据库连接步骤
17-2-2：JDBC原理
17-2-3：JDBC编程原理
17-2-3-1：使用JDBC需要用到哪些类
17-2-3-1：JDBC的DriverManager是用来做什么的？
17-2-3-2：statement的实现原理
17-2-3-2-1：JDBC中的Statement 和PreparedStatement的区别？
17-2-3-2-2：PreparedStatement的缺点是什么，怎么解决这个问题？
17-2-3-3：execute，executeQuery，executeUpdate的区别是什么？
17-2-3-4：JDBC的ResultSet是什么?
17-2-3-4-1：有哪些不同的ResultSet？
17-2-3-4-2：JDBC的RowSet是什么，
17-2-3-4-3：有哪些不同的RowSet？
17-2-3-4-2：ResultSet有两种并发类型。
17-2-3-5：JDBC的DataSource是什么，有什么好处
17-2-3-5-1：如何通过JDBC的DataSource和Apache Tomcat的JNDI来创建连接池？
17-2-3-6：java.util.Date和java.sql.Date有什么区别？
17-2-3-7：SQLWarning是什么，在程序中如何获取SQLWarning？
17-2-3-8：如果java.sql.SQLException: No suitable driver found该怎么办？
17-2-4：JDBC事务
17-2-4-1：Java中如何进行事务的处理?
17-2-5：JDBC中大数据量的分页解决方法?
17-2-6：常见的JDBC异常有哪些
17-2-7：JDBC中存在哪些不同类型的锁?
18.分库分表
18-1：为什么要分库分表？（看法）
18-2：数据分表
18-2-1：垂直分表
18-2-1-1：垂直切分解决了什么问题
18-2-1-2：垂直切分不能解决什么问题
18-2-2：水平分表
18-2-2-1：水平切分的用途
18-2-2-2：水平切分的缺点
18-2-3：为什么先做水平切分，后作垂直切分？
18-3：数据分库
18-4：数据库的扩容
18-4-1：为什么要数据库扩容
18-4-2：主从数据库扩容
18-4-3：双写数据库扩容
18-5：分库分表，id如何处理（04期还没有看完）
18-6：分库分表如何保证主库和分库的事务性
18-6-1：什么是流水（53期）
18-6-2：为什么不用事务消息
8-6：等等
内容很多，这个也只是条目，具体的细节，可以问我，免费给各位
九、各个公司面试经验贴
9-1：字节面试
9-1-1：一面
- 自我介绍
- 刷题，leetcode原题，但是方法他的意思是需要层层递进
- 问了我计算机网络http的底层原理，还有1.0、2.0、3.0
- HTTP的请求组成部分
- TCP、UDP区别
- TCP为什么是可靠的，底层是如何实现可靠传输的
- 虚拟内存的概念，以及虚拟地址还有他的处理方式
- 写了一套sql题目
- 反问
9-1-2：二面
9-2：百度面试
我投递百度时间比较晚了，因为我是十点预约的，可能大家都有offer了，缺席的人还挺多的，然后我大约九点就开始面试了，
9-2-1：一面
- 自我介绍，他说我java学的时间确实有点短，为啥去报这个方向
- 项目介绍，没问很深
- 出了一个题，就是经典的动态规划问题，换钱最少货币数
- 做完之后，问我能不能继续优化，进行了继续升级
- 开始说一下这个题你的思路，有没有更好地思路
- 开始问基础，先问了我new int存储在哪里?我跟他说基本类型不能new吧，后来才知道go语言可以，好神奇
- 问我堆和栈的那个级别更高？主要存储什么东西?new出来的东西一定会存储在堆里面呢？那你认为他应该存储在哪里？你的判断依据是什么？那你觉得如何判断我的对象是新生代和老年代？
- 垃圾回收算法有哪些，用在新生代还是老年代？为什么新生代都是复制算法，老年代都是标记整理算法？
- 说一下你知道的垃圾回收器？
- 问我一个C++三种继承方式，我记得我研一看过，我就大体说了一下，没有说太好
- 没有反问，让我喝口水，十分钟继续二面(当时我已经惊呆了)
9-2-2：二面
- 自我介绍
- 项目
- 问我hashmap一堆东西，还有io的复用问题
- 反射怎么理解的？你怎么使用反射
- 字符集种类，有了Unicode为啥还需要UTF-8，UTF-8编码原理
- String为什么是final的？String的常用方法，你看过String源码呢？我傻啦吧唧的说看过，subString原理说一下，
- String str="abc",堆和常量池中的情况
- Error和Exception的区别
- 继续刷题，题目记不清了，leetcode原题，我从o(n^2)---o(n),问我还能不能继续降低，我说应该可以，但是我说我不会了
- 没有反问，他说那你等待三面吧，我擦，当时真的要惊呆宝宝了。（我喝了口水，压压惊）
9-2-3：三面
- 自我介绍
- 项目，让我详细介绍项目
- import *调用的是本级目录文件还是递归目录文件？
- 单点登录扣得很细
- 数据库的密码保存问题
- 智力题
- 面试结束，让我等待结果
9-2-4：hr说薪资，没有hr面
我大约11:30面完的，然后12:00hr打过电话来，问我对工资预期，还有拿了几个offer，问我愿不愿意来百度？
9-3：京东
我是截止9.20ru所有大厂中唯一一个有拿到offer的，因为当时实在是太菜了，很多东西都没有准备好，就准备拿京东练练手了
一面：
死问项目，你这个东西的原理是啥，我说了个单点登录，就开始问了很多一直问到你不会为止，反正我答的很差
（ps：他说你做视觉的，做java可能转变有点难）
然后开始了java基础之路：
1.为什么分为基础数据类型和引用数据类型，String是不是？
2.String为什么不可以修改？final？那你知道final的作用呢？既然他的底层结构知道了，那你知道他的线程安全不？那你知道还知道什么String类线程安全？这三者区别你知道不？（就是String、StringBuiler、StringBuffer），你知道String常用方法不？你知道subString原理不？
3.之后就开始了euqals与==的漫长之路，两个都是String st1 = "abc"是否相等？一个创建对象，一个String str1=“abc”相等不？一个是String str1=a+b+c，一个String str2=abc相等不？两个都是new String对象相等不？不管想不想等，都让我说了原因
- 然后开始了集合家族的问题
hashmap结构？为什么是红黑树？旋转与着色怎么搞？手撕put操作，然后hashmap的put与get的时间复杂度，哪几种线程安全？ConcurrentHashMap扩容机制，为什么 ConcurrentHashMap 比 HashTable 效率要高？hashmap与 ConcurrentHashMap中扩容的区别？arraylist、linkedlist区别和适用场景？treeset、hashset区别和适用场景？
5.问了一下JVM，我说不太会，他就问了我一下垃圾回收机制
6.手撕代码，0-1背包问题，反正我记得是leetcode原题
7.你觉得你身上最大的优势是什么？
8.反问
问他部门是干啥的
有没有下午茶（最尴尬的一个问题o(╥﹏╥)o）
二面
死问项目，然后问承担了什么责任？你觉得一个团队当中你适合什么角色？你对这个项目社会价值的评价（心理一万个TMD）
既然你用到了计算机网络，我问你几个问题
1.讲一下Http，HTTP安全不？HTTPS如何解决的？HTTP的数字证书如何认证？
2.TCP与UDP区别？，TCP为什么要四次？为什么TIME_WAIT 等待的时间是 2MSL？已经主动关闭连接了为啥还要保持资源一段时间呢？TIME_WAIT 过多有什么危害？如果已经建⽴了连接，但是客户端突然出现故障了怎么办？保活机制说一下？
- Cookie 和 Session 的区别
- 数据库三大范式是什么？并举例
- ACID靠什么保证的（我认为也就是底层原理），说一下undolog，那redolog说一下，MySQL如何保证redo log和binlog的数据是一致的，如果一个sql执行很慢，你能分析一下原因呢？然后说为什么数据库会选错了索引
- 来了个sql场景题
- 两道手撕代码结束全场
- 反问
之后是HR面还是技术面
京东的员工福利（(ー`´ー)）
部门额待遇
三面 HR面
家是哪的？愿不愿意来北京？有没有女朋友？女朋友也来呢？为什么学这个方向，你觉得你最大的强项是什么？你觉得你的发展史怎么定位的？。。。。很多，反正就是通常的hr该问的，都问了
大华
一面二面三面很快，基本上9.25一面，9.27二面，9.27晚上三面，9.28拿到offer
一面（15min）我以为我挂掉了
1.还是项目
2.根据项目问技术
3.然后问我springboot启动流程（我是真忘记了）
4.spring你是怎么认为的，ioc，aop说一下
5.那你自己设计一个ioc怎么设计
6.aop代理模式，然后讲一下动态代理
7.你知道哪几种设计模式
8.单例说一下，然后手写单例（懒汉式）模式
9.一二级缓存机制
10.spring的循环依赖以及解决方案
11.说了一下重建二叉树的思路
12.反问
二面（35min）
0.依旧还是项目
1.Http说一下
2.你觉得TCP为什么要三次挥手，挥手后做了什么操作
3.Java8多了哪几种新功能
4.说一下lambda表达式，问了几个功能
5.hashmap，从数据结构到扩容到put、get操作，到线程安全到与hashtable等比较等等
6.Class.forName和classloader.loadClass的区别
7.什么是OOM？常见有哪些OOM
8.溢出举个例子
9.新生代和老年代，为什么是8:1：1
10.强、软、弱、虚引用以及区别
11.Java对象的创建过程
12.如何创建对象
13.图BFS,DFS
14.你认为你的优势
15.反问
HR面
正常问题，不记录了
平安科技
一共五面，是最痛苦的一个公司
一面：
1.自我介绍，问我为啥去学计算机相关的，不去做自动化
2.你觉得你学习计算机优势在哪里
3.你这个项目单点登录怎么做的？用了什么技术
4.redis知道呢？知道，好了木了
5.说一下mysql主从复制
6.你觉得在主从复制中这个过程是如何实现的？
7.你这个项目sql注入问题怎么解决的？用了什么样的思路？还有没有其他解决方案？
8.mybatis的#与$问题
9.你知道java当中的锁呢？说几个
10.轻量级锁、重量级锁说一下原理
11.synchronize关键字说一下理解
12.i++与++i是否线程安全，volatile能保证呢？
13.创建线程的方式，并让手手写了你认为熟悉的一种创建方式
14.并发级别
15.进程通信方式，线程通信方式
16.ThreadLocal（具体问题记不清了）
17.手撕代码，leetcode3、leetcode51，原题
二面：
- 自我介绍
- 项目
- 还是java基础---IO、hashmap、反射等等吧
- springboot启动原理
- spring与springmvc区别
- 你怎么看待servlet与tomcat和springmvc
- servlet的过程
- tomcat创建过程
- TCP传输数据优化
- 超时重传
- sql场景题，从a表中提取出b表中存在的并且重复信息
- 反问
三面:
谈理想，谈未来，谈抱负
四面：
压力面试
五面：hr面
海康威视
一面：
- 项目
- 二分法
- 索引，索引分类，B+树比B树的优势，B+树与hash索引比较，创建索引原则，最左前缀原则，创建索引的方式
- 数据库优化
- spring的ioc，aop
- hashmap
- 你知道哪些线程安全的map
- 你觉得如何保证线程安全以及线程安全的方式
- 线程安全的意义是什么
- 内存溢出与内存泄露举例说明
- 虚拟内存
二面：
hr面
顺丰科技
测评：挺难得，当时是凌晨三点睡不着了，起来做的
一共两面+hr面
1.自我介绍
2.项目，但是对我的项目不足之处提了几点建议，我觉得可以用在我的毕业答辩上
3.springboot你学过多少，就问了几个简单的几个springboot注解问题还有原理
4.spring事务隔离界别与数据库隔离级别有何关系
5.数据库隔离级别如何实现的？
6.数据库当中你知道哪些让用锁
7.数据库的优化——explain介绍一下
8.JDBC创建过程
9.JDBC常用类
10. 为什么要分库分表？
11. 分库分表如何保证主库和分库的事务性
12. 链表成环说一下
13.反问
HR面
基本问题
小米
一面：
1.个人介绍，因为我本科参加过电子设计和智能车，就开始问智能车取得成果以及用了什么算法，算法当中你遇到了什么困难，如何解决。
2.开始问java了
3.java基本数据类型范围，有哪几种
4.包装类型与基本类型区别
5.i++与++i区别
6.synchronize底层原理，你知道monitor呢？属于什么类型的锁
7.除了用锁保障安全，还有没有其他方案
8.euqals与==问题
9.hash函数以及为什么要重写hashcode与equals，阿里关于hashcode和equals的处理规则（这个问题真的是不知道）
10.hashcode和equals源码写一下
11.hashmap
12.哈希冲突的解决方法
13.java中几种解决同步问题的方式
14.如何判断共享数据不会被线程竞争？
15.常规实现线程池方法
16.手撕代码：快排和字符串反转
二面：
1.项目
2.你的梦想是什么
3.你觉得你的优缺点是什么，如何改善的？
4.你在项目当中有没有遇到困难，如何解决的？在解决过程中你觉得你自己最大的挑战是什么？你与团队成员的关系，你所承担的责任
5.问了些基础
全部评论
(29) 回帖