2.数据库索引都有哪些，介绍一下，然后面试官就问我说话的漏洞，感觉会抓住某一个比较突出的词来逼问，这里除非特别清楚，否则就被问死了，我这里有点虚，回答的有点犹豫，b+树，hash索引，b树索引
4.乐观锁和悲观锁，我说到了cas，然后问我java中有哪些地方用到了cas，然后我说concurrenthashmap，然后是咋用的，这个类是怎么保证线程安全的，他还说了一个put啥东西我没注意，就说不知道。chm，原子类，AQS等。chm在put操作没有冲突时进行cas尝试，直到成功。原子类使用cas执行自加自减操作防止并发问题。AQS的修改state也是使用了cas操作。5.问我序列化，然后问到了远程方法调用，我说没接触过序列化主要是把对象压缩成二进制数据，进行网络传输，rpc就是基于序列化和网络通信编程实现的。6.问我项目是练手还是买钱，他笑着对我说，我也笑了7.dao层是model层吗？这个以前没注意，就说是，也不知道对不对，记得以前面试好像有面试官问我model和pojo的区别差远了。dao是数据持久化层，负责数据库操作，model负责数据模型。8.索引在什么情况下会失效，这个当时有点激动，想了一下没说出来，有点遗憾，前缀匹配，没用用到，函数，判空，<>等今天面试，面试官给人的感觉很强势，会抓你回答问题的漏洞，也根据我的语气问我不熟悉的地方，剩下的问题没想起来，面了30分钟，面试官很nice
阿里一面
说说现在能写出来哪些排序算法快排，冒泡，选择，归并，插入，堆排序。计数排数，桶排序。
在学校有没有参加社团之类的有的。
给定一个文件名，如何在d盘找出来这个文件，说说思路。使用操作系统查找。find-name，locate，whereis
就聊了20分钟，感觉问的都很简单。。然而11号晚上面试的，今天还是面试中，是不是要凉了
1.自我介绍，刚开始，有点懵，两句介绍完了，太不好了，2.项目中自己觉得做的最好的地方，因为自己的项目真的没有啥亮点，都是基本业务层的实现，所以说了个前段的，然后嘴贱说了个redis，被问死，面试官说你猜的还是看别人的，我说猜的，然后就尴尬了。3.java虚拟机类加载机制双亲委派加载4.java中的锁
5.反射，怎么实现，一激动说成了序列化，因为Java虚拟机会把类加载到方法区，并且保留Class对象作为每个类的元对象，通过这个对象就可以获取该类的信息，从而获取它的方法，构造函数，变量等内容。通过反射，还可以动态地指定实现类，因为反射可以通过配置文件来配置实现类。然后加载该类到方法区，通过构造方法进行实例化。6.数据库的索引，隔离级别几种，分别是啥，然后就没问了，我还以为会让我详细解释一下。
7.快速排序思想
8.问我jdk看的第几版，嘴贱了一下，说了1.8，然后问我hashmap默认的数据结构，果不其然问到了红黑树，然后问红黑树插入，果断不会，这太套路了红黑树的增删改查都比较复杂，但是就是先操作，然后进行树的调整，保证几个特性符合要求。1根节点是黑节点2红节点不相邻3根节点到每个叶子节点的黑节点数都相同，于是保证整棵树的平衡性。（3）每个叶子节点（NIL）是黑色。[注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！]（4）如果一个节点是红色的，则它的子节点必须是黑色的。
9.问道spring，问我都用到了哪些里面的东西，我说ioc，本来问我ioc的实现，突然，问我控制反转了什么，最后说完这个，就没问实现了，直接问我还有啥问他。
控制反转主要为了对象实例化的解耦，只需要写上接口就可以，通过配置文件或者注解将实际对象注入。并且由Spring的bean容器来管理所有的对象。
感觉不好，开始的项目中的redis自己把自己坑死了，这次面试以前都很开心，这次不知怎么，一点都开心不起来，可能好运用完了
HR姐姐问了项目是怎么开始的，怎么开发的，最后结果如何，遇到了什么困难，组员工作协调得如何。
我就说有些组员的工作完成的有些敷衍，最后不足的部分是我完善的。
HR就这点开始问我各种组长的工作，你把前端的任务交给组员时是怎么想的（我说我以后打算从事服务器后台那方面的开发，所以把前端的任务交给组员来做了）
组员做不好的理由？如果能重来你打算怎么办？
项目最后怎样了？你感觉有什么不足？
个人觉得应该是组员的工作没协调好，让HR姐姐不满意了，还有就是把项目不满意的地方大多都归结在其他组员做的部分。
之前看了些HR的面经，就有人说HR面不能坦诚相待，要把规避短处，我就不应该把项目中组员没好好完成任务，锅全部我来背这件事说出来。吃饭时就感觉不安了，觉得说这些不好，结果真的挂了，好难受。
（上来先问了项目的东西，略。）
ArrayList中删除值为a的元素怎么操作list.remove(a);使用Iterator遍历HashMap，删除值为a的元素会发生什么currentmodfiyexception。也就是拒绝操作，禁止在迭代阶段修改数据，否则会抛出异常，如果modCount不等于expectedModCount，则抛出ConcurrentModificationException异常。很显然，此时modCount为1，而expectedModCount为0，因此程序就抛出了ConcurrentModificationException异常。3.介绍一下HashMap
既然提到红黑树，就说说红黑树
介绍一下Java的gc分代gc，gc算法，gc回收器，jvm调优。
算法题，给定正整数n和x，求1到n中x出现的次数，比如1到12中2出现了两次，分别是2，12中各一次。关于项目，面试官不满意，他以为我了解过openstack云中的neutron模块
关于Java，1只回答了使用remove方法，第2题没明白在问什么，第4题说不会，第6题不会，第7题不会，
算法题，只大致说了思路，从最高位开始递归，但是我一开始讲的太乱了，对方听不下去了最后让我举个例子1024中2的次数该怎么算
最后我问面试官他们的工作是什么，他说做的东西和openstack的neutron功能差不多。
2、现在都学习了些什么？balabala
3、HashMap底层实现原理，是否读过HashMap源码？
4、HashMap和ConcurrentHashMap在线程安全上有何区别？如何实现？
5、项目：小程序。问到遇到什么问题吗？在这里问了好多，还有业务逻辑，感觉答得都不是太好。
6、了解过哪些中间件？
7、Java的特性？
8、Java内存模型
9、JVM类加载机制
10、双亲委派模型
11、Object都有哪些方法？equals，hashcode，clone，wait，notify,notifyall。getclass()，由于方法维护这一个Class对像，通过该方法可以获得该对象，并且使用反射机制获取它的各种信息,finalize，该方法应该是在对象被回收前会调用的收尾工作方法。
12、高并发、高并发、高并发！重要的说三遍。如何解决？答得不太好，一脸懵逼！高并发。解决方式：1前端负载均衡，如果是web，可以前后端分离，cdn处理静态资源。2ngnix7层负载均衡，转发到多个应用服务器。3在数据库之前加上缓存。4数据库读写分离。主从部署。5如果有秒杀场景，再通过消息队列对请求进行削峰再到达缓存层。6机器配置提升，代码优化，使用并发编程，使用异步IO或者多路复用
13、锁优化CAScas实现轻量级锁和偏向锁，不需要synchronized底层使用mutexlock切换上下文。
14、sychronized和volitile
重量级锁。内存屏障实现volatile变量的读写语义。
15、还问了我的英语怎么样？考六级了吗
17、看了我的博客（挺开心的，感觉博客搭建上还是挺好的），问我是自学吗？一般怎么学？
18、了解Linux吗？确实没咋用，就说了知道几个命令。
19、觉得自己是一个怎样的人？
十分幸运拿到阿里云的offer，感谢周围无数人对我的支持和鼓励，所以写篇面经希望可以帮助大家。面试中，运气占很大一部分的，所以你们若是没有通过，一定不要气馁，继续加油。每个努力的人都值得钦佩，无论结果如何。
我说点面试中的小技巧，可以帮助你更好发挥，（注意，这个方法比较适合我，不一定适合你哇）完全可以将学到的知识讲给自己（或者讲给别人），若是自己（别人）听你的讲述能够听懂（使用自己的话去讲，而不要有专业术语），那么说明你已经学好了。其原理就是费曼学习法。感兴趣的人可以去了解下。
我个人习惯于将一个知识点分解为xxx是什么，xxx有什么用，如何实现这个功能的（核心的工作流程），缺点是什么（以及为什么有这个缺点，缺点如何补救）。
举个例子，CMS垃圾回收器回收时为什么有内存碎片，首先分解为CMS是什么，内存碎片是什么？
这些子问题都回答好，那么基本上这个问题就学的可以了。
这样可以检测你是否学好，而且，若是你都没法条理清晰地讲给自己，那怎么条理清晰地讲给面试官呢？
接下来就写下三次面试题目：阿里一面：
1.个人介绍
3.数据库联合索引用法
4.SpringIOC初始化过程1首先实例化一个上下文比如applicationxmlcontext，就会去读取xml文件的bean。2然后解析xml的bean，定义成beandefinition数据结构，注册到内部的一个listablebeanfactory中，该工厂负责beandefinition的保存。3接着根据默认规则进行单例实例化，实例化之前可能会包装动态代理，或者进行属性配置，前置后置方法的调用等。（拦截器）。4然后就可以通过getbean的方式获取这些类的单例了。
5.ConcurrentHashMap实现原理
6.CAS操作硬件支持，aba7.ReentrantLock和Synchronized区别aqswatcher+monitor，底层是mutexlock
8.CMS垃圾回收过程1初始标记gcroot2停顿并且并发标记。3更新标记4并发清除
9.FullGC次数太多了，如何优化。说明可能有promotion问题和老年代空间不足的问题。、
可以减小存活区，提高阈值，增大老年代等。10.直接内存如何管理的直接内存是堆外内存，通过堆内的引用来连接，回收引用时也会通过追踪算法去回收直接内存。直接内存不受到jvm管理，所以适合用作缓冲区。11.线程池参数。
一个题目：如何将一个二叉树，转为有序的双向链表。
阿里二面1.自我介绍2.项目介绍3.堆和栈介绍
4.线程安全
5.乐观锁悲观锁
6.TCP三次握手
7.socket通信有关，selectepoll
8.项目中的难点有哪些
交叉面1.自我介绍2.项目介绍
3.做这个项目的动机
4.TCPUDPIPICMPicmp负责ip地址的探测，以及路由信息的获取。ping和traceroute分别用于探索ip是否可达，和路由信息跟踪。5.知不知道一个应用层协议，运输层既没有使用TCP，也没有使用UDP
6.二叉树中求最长路径。
递归的方式去实现。
先求左子树深度，后求右子树深度。相加减一，那么就是以当前结点为转折点的解。
其实可以优化到O(n)，其实不必求两个子树的解，只需要求较深子树的解即可。
7.有什么想问我的吗？//您觉得成为一个顶尖高手，最重要的是什么呢？
兴趣。做自己感兴趣的事，就不会很疲惫，也会很开心。//这一点我深有同感。
抓住你的兴趣，做你想做的事，自己驱动自己进步。
//很感谢您的建议。
hr面试1.自我介绍。2.项目介绍。项目中难点。得过啥奖没。3.项目有什么不足？4.前面的面试发挥怎么样？5.前面的面试难度怎样？
愿大家都能拿到自己理想的offer。
1、Servlet如何处理多个请求访问？答：Servlet容器默认是采用单实例多线程的方式处理多个请求的：1.当web服务器启动的时候（或客户端发送请求到服务器时），Servlet就被加载并实例化(只存在一个Servlet实例)；2.容器初始化化Servlet主要就是读取配置文件（例如tomcat,可以通过servlet.xml的设置线程池中线程数目，初始化线程池通过web.xml,初始化每个参数值等等。3.当请求到达时，Servlet容器通过调度线程(DispatchaerThread)调度它管理下线程池中等待执行的线程（WorkerThread）给请求者；4.线程执行Servlet的service方法；5.请求结束，放回线程池，等待被调用；（注意：避免使用实例变量（成员变量），因为如果存在成员变量，可能发生多线程同时访问该资源时，都来操作它，照成数据的不一致，因此产生线程安全问题）
问题四：说一下在学习java虚拟机的时候，你认为最难理解的是什么
class字节码的组织结构以及解析过程。
问题五：你怎么解决这些难以理解的点的？
看了一些博客，发现它有独特的解析规则以及语法分析，语义分析等方法。
问题六：JVM的内存划分和每一块的功能
问题七：说一下栈的内存是怎么分配的栈内存包括栈帧，线程私有的。
一：Java堆内存空间Java程序运行时使用javaHeap内存为对象以及JRE类分配内存,不论我们在何时创建何种类型的对象,他总是在堆内存中创建的Java垃圾收集器运行在堆内容空间,释放那些没有任何引用的对象所使用的内存。在堆内存空间创建的任何对象都具有全局访问权限,并且可以从程序的任何位置引用二：Java栈内存空间Java栈内存空间用于执行线程,栈内存始终遵循LIFO(Last-in-first-out)顺序,每当一个方法被执行,会在栈内存中创建一个新的block用于保存在函数中定义的基本数据类型变量以及对象的引用变量当方法结束时,thisblock改变它的状态为未使用并且可用于执行下一个方法栈内存大小与堆内存相比非常少。
1,堆内存属于java应用程序所使用,栈内存属于线程所私有的,它的生命周期与线程相同2,不论何时创建一个对象,它总是存储在堆内存空间并且栈内存空间包含对它的引用.栈内存空间只包含方法原始数据类型局部变量以及堆空间中对象的引用变量3,在堆中的对象可以全局访问，栈内存空间属于线程所私有问题八：说一下栈帧的内存是怎么分配的栈帧（StackFrame）是用于支持虚拟机进行方法调用和方法执行的数据结构，它是虚拟机运行时数据区中的虚拟机栈（VirtualMachineStack）的栈元素。
栈帧存储了方法的局部变量表、操作数栈、动态连接和方法返回地址等信息。每一个方法从调用开始到执行完成的过程，就对应着一个栈帧在虚拟机里面从入栈到出栈的过程。问题九：HTTP1.0和HTTP1.1的区别
长连接HTTP1.0需要使用keep-alive参数来告知服务器端要建立一个长连接，而HTTP1.1默认支持长连接。HTTP是基于TCP/IP协议的，创建一个TCP连接是需要经过三次握手的,有一定的开销，如果每次通讯都要重新建立连接的话，对性能有影响。因此最好能维持一个长连接，可以用个长连接来发多个请求。
节约带宽HTTP1.1支持只发送header信息(不带任何body信息)，如果服务器认为客户端有权限请求服务器，则返回100，否则返回401。客户端如果接受到100，才开始把请求body发送到服务器。这样当服务器返回401的时候，客户端就可以不用发送请求body了，节约了带宽。另外HTTP还支持传送内容的一部分。这样当客户端已经有一部分的资源后，只需要跟服务器请求另外的部分资源即可。这是支持文件断点续传的基础。问题十：hashmap和hashtable的区别
问题十一：之后就是谈谈一些家庭情况————————华丽的分割线————————————————————总之阿里的面试还是很偏重于基础和底层的一些东西
阿里-一面-自我介绍-校园经历，成绩，怎么学习新知识，未来的学习规划-项目为什么用redis，redis集群
了解的集合类，hashset原理，arraylist和linkedlist的区别，性质
多线程项目用没用过，线程的调度，函数的具体含义
数据库水平切分，垂直切分
数据库优化
两个字符串数组，比较是否相等，忽略顺序
你有什么想问我的
阿里一面面试官评价基础还行，工程还得加强，挂
报的java后台，3月中旬简历面，昨天现场一面，今天查到被拒了。1自我介绍2擅长什么（jvm,数据结构，并发，算法，数据库）
3说说并发，里面包括些什么11AQS是并发包的基础，提供了一些方法的实现，比如state，lock和unlock的方法，还提供了阻塞线程使用的clh阻塞队列。
2Lock通过AQS实现锁，内部有两个实现类fairsync和unfairsync继承AQS的Sync抽象类。condition则自己实现阻塞队列，和lock配合使用。
3原子类使用cas操作完成原子操作，保证线程安全。底层基于unsafe包的cas方法实现，而cas方法又是由硬件提供的功能。
4阻塞队列分为很多种结构，比如数组，链表。无界队列等，可以通过其实现经典的生产者消费者模型。
5线程池则是通过对阻塞队列，线程组，任务进行封装，实现了一个可以复用线程的线程池，其中也分很多种。
6并发容器如chm和copyonwritelist，跳表，保证读取的线程安全，并且在写时通过同步操作或者复制的方式保证并发安全。
7并发工具类：countdownlatch和samphere基于AQS的共享锁实现，cliderbarrier基于lock和condition实现。还有exchanger。
8辅助类，locksupport，专门用来阻塞线程等功能。4说下ConcurrentHashMap你知道些什么？怎么设计的？为什么不同的key会放在相同的位置？
5volatile有什么用？可见性怎么实现的？1volatile保证原子性和可见性。原子性是保证单个变量的读写是原子性的，不会出现double被切割的情况。可见性是通过内存屏障来实现读写语义的，遇到读内存屏障直接从主内存读取，遇到写内存屏障直接写入主存。6讲讲知道的数据结构（ArrayList,LinkinedList,HashMap,HashSet,Stack）
介绍项目，线程，进程的区别，线程的调度方式，线程和进程间通信，线程的状态，
四、线程的调度线程的调度，取决于支持的是内核级线程还是用户级线程。
对于用户级线程，内核不知道线程的存在，就给了进程很大的自主权。内核只是调度进程，进程中的调度程序选择哪个线程来运行。
对于内核级线程，线程的调度就交给了系统完成。五、Linux中的进程与线程调度首先明确一个概念，Linux系统中甚至没有真正的线程。不过，可以认为Linux是系统的线程是内核线程，所以调度是基于线程的。一个进程由于其运行空间的不同,从而有内核线程和用户进程的区分,内核线程运行在内核空间,之所以称之为线程是因为它没有虚拟地址空间,只能访问内核的代码和数据,而用户进程则运行在用户空间,但是可以通过中断,系统调用等方式从用户态陷入内核态。用户进程运行在用户空间上,而一些通过共享资源实现的一组进程我们称之为线程组,Linux下内核其实本质上没有线程的概念,Linux下线程其实上是与其他进程共享某些资源的进程而已。但是我们习惯上还是称他们为线程或者轻量级进程。因此,Linux上进程分3种，内核线程（或者叫核心进程）、用户进程、用户线程,当然如果更严谨的，也可以认为用户进程和用户线程都是用户进程。Linux中，进程和线程都被维护为一个task_struct结构，线程和进程被同等对待来进行调度。Linux将线程区分为3类：（1）实时先入先出。（2）实时轮转。（3）分时。
hashmap的扩容，put方法，实现，基本都问了，hashtable，concurrenthashmap。略arraylist，linkedlist都问实现，区别，list中还有哪些是线程安全的。略我说到hashmap1.8实现，链表长度大于等于8就转红黑树。然后，果不其然，问我红黑树，不会略
spring的aop和ioc，有哪些设计模式，叙述单例模式，我叙述完他问我单例是不是线程安全的，我说不是，就问他是不是要问我double-check，他说是，我两个都笑了，我说我不会，然后让我说责任链模式。1饱汉2饿汉3同步4双重检查5静态内部类6枚举类
synchronized锁解释，还有它的膨胀机制。偏向锁，轻量级锁，重量级锁
线程的状态都有啥？还有wait方法，
火车票抢票，只有一台服务器，瞬时访问量很大，如何系统的解决？前端页面限制，url屏蔽，缓存，消息队列，负载均衡。
问我你看哪些书？我说并发编程实战，编程珠玑，然后问我并发编程实战的作者是谁？这些书你都买下看过没？dougleaJava并发编程之父
问我区块链知道不？说一下，
问我最近有哪些新技术？我说java10发布了，他说你先别管java10，说一下java8都更新了什么？我说知道lambda表达式，我说还对hashmap做出了优化，他问还有啥？我说好像还有函数式编程，他说函数式编程不就是lambda表达式吗？
1lambda和函数式编程2接口的默认方法3日期和事件api4流式集合和api5option方法。6chm等集合的优化
OOP理解：继承vs组合
英文交流：自己找话题，以及看过那些书，非专业的书
觉得这次面试主要是考察思想和理解，比如在过去的某个经历中，是否真的学到了或者理解了什么。还有面试官有提到passion，觉得也可能想考察是否适合这个团队。
觉得视频面试需要注意的就是，要微笑，要显示出自己很有热情，即使是聊天，一定要说一些体现自己的经历、理解和思想的问题，要说一些面试官可能感兴趣的事情，比如在英文聊天的过程中，因为面试的是B2B团队，我就说了上学期针对一个美国CRM公司做的调研，然后进行展开。关于技术问题也是主要考验是否深入理解，中间即使遇到不太熟练的问题也要表现的很虚心认真，边听边记下来。
总之觉得，能遇到这种比较重视思想和理解以及软实力的面试官，可以说是很幸运了，可以在聊天的过程中了解到个人学习和理解能力，个人积累，以及个人态度，还是很重要的。收藏(10)
简述TCP三次握手、四次挥手
TIME_WAIT为什么要等待2MSL，TIME_WAIT是客户端状态还是服务端状态
1防止server没有收到最后一个ack，则会重发fin请求2让本次连接中的请求都过期。
TCP和UDP的区别，你的手机上有哪些App会采用UDPqq。udp发送信息不需要建立连接，所以有时候会发送失败直播也可以使用udp，否则重发机制和有序要求不适合直播，允许出现小丢包
HashMap是线程安全的吗，有哪些线程安全的容器，HashMap底层用什么数据结构实现的，put方法是怎么实现的，怎么解决哈希冲突，怎么扩容
介绍一下ConcurrentHashMap,get方法是怎么定位到某个具体的位置（JDK1.7环境下）hash值，然后和表长相与，然后定位到数组索引，接着搜索链表或者红黑树介绍一下CopyOnWriteArrayList的应用场景以及实现原理读多写少的场景单例模式的实现代码，以及该模式主要应用在哪些场景1任务管理器就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windowstaskmanager吗？2（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。3.网站的计数器，一般也是采用单例模式实现，否则难以同步。4.数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。5.多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。Jvm内存溢出的种类栈内存，堆内存，方法区数据库有了解过吗，自己在下面安装的过什么数据库，MysqlOracle
mysql有什么需要问的
二面：撸代码，最大子数组求和问题最大子数组的和。用dp可以解偏智力题，小白鼠验毒药问题一只小白鼠表示0或1,10只小白鼠可以组成10位的二进制数，2的10进制是1024。比如0000000001表示第一瓶酒，0000000010表示第二瓶酒，当毒发时，根据之前的结果，小白鼠可以排成一个数，中毒的时候，排成的这个数就是有毒的酒介绍一下Jvm的内存模型，有哪些是线程安全的线程私有的栈是线程安全的，本地方法栈是共有的，非线程安全的。Jvm垃圾回收算法，新生代采用什么算法，老年代采用什么算法略i++,线程A：i++,线程B：i–，在非线程安全的情况下，i有几种取值，采用什么方法使得i线程安全1同步2volatile数组和链表的比较
HashMap是如何解决哈希冲突的
HR面：你是怎么知道这个部门的，你对这个部门有哪些了解
你还投了哪些公司的招聘，你同学还投了哪些公司，如果很多家公司给你offer，你会选择哪一家
你希望留在哪个城市，为什么
你在学校做过什么项目，你实习的项目和学校做过的项目对该职位有什么帮助
有什么需要问的
总结：春招实习之路真的是很艰辛，自己本来也不是CS方向的，很多基础课和本专业的同学差距真的太多，但是只要足够努力，必定会得到一个满意的结果，路漫漫其修远兮，吾将上下而求索。大家加油！
可以查看锁的状态,锁是否被锁上了.
可以查看当前有多少线程再等待锁.
CAS
内存泄漏与内存溢出，及其原因
数据库四种隔离级别
Spring框架介绍
OOP设计原则0开闭原则1里式替换2单一职责3依赖倒置4迪米特原则：对象对其他对象的引用越少越好。
面试官人很好，面试完之后，请面试官针对我的下一步学习计划提建议，结果面试官说几次想引导我去回答更深入的问题，都没引导过去[捂脸]。之后针对面试官的建议，把缺漏的知识点再整理了一遍。面试官当时说大概一周会有结果，等了一周半，以为凉了，就抱着必死的决心，向面试官问了下情况，竟然就接到了二面视频面试邀请。结果面试被拖后(鸽)了。
想问一下各位，有经历过视频面试的同学吗？请问视频面试流程大概是什么样的呀？如果是视频的话会要求共享桌面吗？视频面试主要会考编程吗？看了一下面试官的Title是PrincipleSoftwareEngineer应该不属于主管面把？我人不再国内，不知道这个视频面试是否相当于现场面试？求大佬们帮忙答疑解惑，感谢
楼主南开大学大三计控弱渣一枚，只面了15分钟，妥妥的凉了。。
1.自我介绍2.介绍自己做过的项目。3.聊到HashMap，问HashMap什么情况下发生死链（自己引过去的，resize的时候），实际碰到过吗应该说的是反生链表死循环访问。是在put过程中引起resize操作，然后在扩容时出现了新链表和旧链表的同时操作，导致新链表的指针指向自己。形成死链。4.Java什么时候会发生内存泄漏(静态全局变量添加了很多数据没法被GC，连接资源不释放)（PS：我和你聊GC，你就不打算和我聊聊GC吗？！）静态容器存储很多对象。连接池资源不释放，监听器等对象没有被回收。一些默认不释放的资源没有手动释放，比如hibernate的session，数据库连接池，lock锁，jedis池
5.项目用的什么数据库，建了哪些表，有什么考虑？
6.索引一定有效吗？失效的情况？索引是怎么实现的？（我就应该和面试官聊索引实现的。。）不一定有效。全表扫描，非前缀索引等等。索引使用b+树实现。innodb支持聚簇索引。
学了哪些课程？开源项目了解过哪些？
进程和线程的区别
什么时候发生死锁？如何解决？（死锁产生的四大条件，通过破坏四个必要条件之一，如调整加锁顺序、设定加锁时限超时放弃、死锁检测、死锁避免的银行家算法可解决死锁问题）
可重入锁为什么不会导致死锁？（因为上一个问题我回答了不可重入锁会导致死锁，面试官接着就问了可重入锁的原理，我就说了一下第一次加锁就获取该对象的Monitor，当Monitor计数器不为0时，只有获得锁的线程才能再次获得锁，并且每次加锁Monitor计数器就会加一解锁就会减一，当计数为零就释放对象的锁了）
ConcurrentHashMap和HashMap的区别（我说我先将一下HashMap吧，put方法get方法扩容机制blablabla，面试官：你讲一下两者的区别就行啦，估计是知道我们都背得滚瓜烂熟了）
计数器原理（由于单线程，可以避免并发问题，保证不会出错，而且100%毫秒级性能！爽。命令：INCRBY）
全局id生成。（单线程避免并发问题）介绍一下快排（复杂度也没问，就说了一下步骤和原理）
数据结构的理解、区别、优缺点、实现原理（数组、链表、栈、队列）？
动态规划、贪心算法有没有解决过实际问题？
没有，但是它们的思想都挺适合解决实际问题。
数据库三大范式？第一第二第三
操作系统虚拟内存管理？虚拟内存主要是分页和分段。一个页面映射磁盘的一块空间，一般是8k和16k，根据需要调度到内存中。物理上分页，使用多级页表加页表缓存，同时配备地址转换器。逻辑上分段，避免内存段、越界访问。段页式结合，集两者之大成。面向对象与面向过程的区别？按照顺序写代码二面回答太烂了，面试官面了30分钟就不想问了。本来自己准备得多的JVM、计算机网络、多线程、数据库全都没问，后来想想应该要引导一下面试官往那方面问的。哎，还是自己太渣…
前面基础题都很简单（TCP/UDP区别，数据库索引，进程与线程区别，jvm内存区域划分，并发编程），
总结一下就是：1innodb支持外键，事务以及行级锁，另外还支持聚簇索引。
2而mysiam不支持上述特性，但是他在count场景速度快（因为保存了行数）。
3另外由于innodb需要维护聚簇索引，以及事务的MVCC特性，需要额外的开销。所以在查询方面，innodb可能会稍逊一筹。
4而插入方面，由于innodb支持行级锁，所以对于行级插入删除速度很快。最后一题是让我设计一个爬虫系统并将信息进行展示，用户可以查询，说是要看我系统设计思维。
having语句：同样使用本文中的学生表格，如果想查询平均分高于80分的学生记录可以这样写：
SELECTid,COUNT(course)asnumcourse,AVG(score)asavgscore
FROMstudent
GROUPBYid
HAVINGAVG(score)>=80;
在这里，如果用WHERE代替HAVING就会出错
————————————————更新一波，三面交叉面面完，是天猫的大佬面的，
全程就一个技术点，lock和synchronized的区别，我就直接从对象头那开始讲，到AQS的基于state和cas。
一个对象包含了对象头，对象元数据指针，以及补齐位。对象头主要包含了锁标识，gc阶段等信息。
对象头信息是与对象自身定义的数据无关的额外存储成本，但是考虑到虚拟机的空间效率，MarkWord被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据，它会根据对象的状态复用自己的存储空间，也就是说，MarkWord会随着程序的运行发生变化，变化状态如下（32位虚拟机）：
简单介绍了Java对象头，我们下面再看Monitor。
1偏向锁的实现：偏向锁不需要使用类似lock中的cas操作获得锁，而是通过判断对象头中maskword的偏向锁线程id判断自己是否获得了锁，如果不是则检查偏向锁是否开启，如果没有开启则使用（膨胀为轻量级锁），如果开启了就尝试用cas操作把线程id改为自己的id。
2轻量级锁的实现。把对象头中的maskword复制到当前线程的栈帧中，然后使用cas操作尝试使对象头的指针指向锁记录maskword，如果操作成功则获得锁，如果失败，则尝试自旋获取锁。
3如果轻量级锁升级，则变成重量级锁，也就是monitorin和monitorout。
面完之后，找内推人问了一下状态，就差HR面了。================================================今天下午面完HR面了，阿里的面试流程全部走完了。有所思，有所悟。HR说四月下旬才会出结果，感觉HR面的一般，接下来就等消息了。祝大家都好运，拿到自己喜欢的offer。————————————————刚刚查看状态，已回绝。本次阿里春招到此结束。
本人是学习ACM的，平时写C++比较多，莫名其妙的面了Java岗，
你说我本来好好的写C++，怎么就突然来面Java了，
面试的开始时候内心是崩溃的，一开始他问了我Java的Hashmap，
我记得我用过一次就简单的说了说，之后问了我快排，和Hash表
以及Hash表的处理冲突问题，个人觉的不是很难，又问了我一些数据库和操作系统的知识，分布式，索引，B树啥的。
然后是算法题，问找前100大的元素，我把他转换成了用nth_element求第K大元素的算法，听说正解是维护一个堆
小顶堆。每次替换掉堆顶元素，之后进行调整，最后就是前100大的元素了。
感觉，感觉两者复杂都差不多，面试官也就没问啥，又问了我的一些项目(其实也没啥项目)，又问了我最近看了什么书，扯了一些其他的
最后他给我的建议是，要拓宽知识面。然后就没了。感觉阿里凉了。
项目中用过什么面向对象的设计原则（没答出来）开闭（不要改代码，通过继承或者实现接口来扩展），单一职责（一个类负责一件事情），依赖倒置（依赖接口，而不要依赖实现，否则改代码牵一发动全身，并且依赖接口可以动态注入实现类，也就是使用反射机制），里式替换（代码中子类可以替换父类），迪米特原则（对象之间不要有过多依赖，擅于使用中间层解耦）。项目中除了单例，工厂模式，用了什么设计模式解决了什么问题。（没答出来，没准备）观察者，也就是监听器模式，解决了生命周期问题，比如容器启动时做什么，容器关闭时做什么。
代理模式，实现rpc调用少不了动态代理，aop也使用动态代理。
适配器模式，经常需要使用适配器来适配数据表model和视图model，完成实例的转换。
讲下spring是怎么加载类的。（源码）Spring初始化bean容器（外部表现为一个context），然后通过解析器解析每个bean，得到beandefinition实例，注册到map中，然后进行实例化，实例化阶段可能会有前置和后工作需要完成，也可能需要包装为动态代理对象。
当然，我们还需要先实例化依赖，把依赖注入到对象中。问个开发性的问题，假如广州没有一座消防站，现在问你要建立几座消防站，每个消防站要配多少名消防官兵，多少辆消防车。请你拿出一个方案。（我真的不知道他想要我干嘛）
此时一阵凉凉的清风吹过。。这TM是什么套路。全程23分钟。逃过了一面，最终还是死在了二面。。猝不及防的问题。真的，此时我才意识到面试真的不仅要考验你的技术，还要考你的语言表达能力，思维能力等各方面的能力。我语言表达能力真的不行。建议大家以后要多练练，好好准备。最好是能找几个朋友模拟下面试。。。面完我就只想回家过清明了。。祝大家好运。
首先让自我介绍
问项目，给了两个具体的情景让优化
问项目在安全方面有什么考虑吗（并没有，被面试官鄙视了）1前端过滤内容。2后端检验文本内容是否合法，使用Java自带工具即可。3加密密码，使用md5+盐的方式保证密码安全。4过滤敏感内容，使用字典树完成，匹配成功就会被过滤。5防止sql注入，所以要使用mybatis的#，自动加上转义，而不使用$（可能导致注入））。当然通过preparestatement也可以。
数据库的行级锁和表级锁行级锁加在索引上。myisam的非select操作默认都要加表锁。
悲观锁和乐观锁思想
InnoDB会根据以下两个条件检查每行记录:a.InnoDB只会查找版本早于当前事务版本的数据行(也就是,行的系统版本号小于或等于事务的系统版本号)，这样可以确保事务读取的行，要么是在事务开始前已经存在的，要么是事务自身插入或者修改过的.b.行的删除版本要么未定义,要么大于当前事务版本号,这可以确保事务读取到的行，在事务开始之前未被删除.只有a,b同时满足的记录，才能返回作为查询结果.
MVCC简介：
1innodb有快照读和当前读两种模式。
2当前读需要加锁，selectlockinsharemode上读锁或者lockforupdate直接上写锁。其他更新删除操作都属于当前读，需要加锁。
3快照读不加锁，使用select方法，执行的mvcc控制协议。
4行锁加在索引上，没索引则锁全表。
后台缓存为啥选择redis，问了redis的数据结构，持久化1Redis是内存数据库，速度快。2redis支持分布式部署，分布式方案成熟，伸缩性好。3redis支持多种数据结构，并且提供持久化方案。
数据结构：string由sds实现。list由ziplist和quicklist实现。zset由跳表（快速查找key）+hash（快速得到score）实现。dict由hash实现。set由intset实现（自动转变数据类型）。
aof采用追加日志的方式,记录日志.rds是快照方式存储数据文件。
项目做压测了吗，用什么工具压测的，大概并发量有多少，你认为自己项目的性能瓶颈在什么地方JMeter是什么JMeter是Apache开源项目的一部分。它最初是为了测试web服务器的性能而编写的，现在它已经作为一个自动化的测试工具和测试数据，以及用于web应用程序、文件服务器、web服务器甚至数据库的功能测试工具。我们将在本教程中探讨JMeter的重要特性。可以通过配置来模拟针对特定web服务器或应用程序的N个用户和线程。它为web应用程序生成一个模拟负载来度量其性能。此外，您还可以通过循环引发几个迭代来获得平均结果，实现断言，并查看测试结果的图形和统计表示。
大量请求同时过来怎么削峰消息队列。
说一下rabbitmq的几个交换模式
一条消息一个消费者，一条消息多个消费者，主题订阅。
了解其他的消息队列吗？（并不了解）
kafka，同样支持1对1和1对多
JVM内存分区，内存泄露与内存溢出的区别堆，方法区，本地方法区，1.7方法区使用永久代实现，永久代别分散在多个地方，1.8方法区使用元数据区实现。
而元数据区则由本地内存接管。
遇到过项目频繁出现FULLGC的情况吗？怎么排查（项目规模小，并没有遇到过）性能调优步骤：
内存：使用jmap转储内存dump文件进行分析。定位oom和内存泄漏问题，比如使用mat和jhat
cpu：通过top+jstack定位进程的异常线程，跟踪调用堆栈，排查问题。也可以通过日志排查，当然通过tprofier直接排查耗时最多的方法，效果更好。
平时怎么学习的，有什么要问我的吗
5：略6,7略8：有。好处：线程复用，方便管理和控制并发数，并且可以提交异步任务。最大线程数和cpu核心数有关吧，是核心数额整数倍，有效利用多核的计算能力。91。5倍扩容。扩容就是复制到新数组。
ArrayList底层是数组，使用索引get，put，delete后调整。
阿里面试面试官都挺和善的就是自己太菜了转专业的心累1面自我介绍ArrayList和linkedlistjvm工作原理然后就没问了说你答的不是我想要的不够深入聊了聊人生还是给了二面的机会
虚拟机可以虚拟硬件，并且提供虚拟的操作系统，重量级。比如VMware，而Linux支持KVM虚拟机，每个kvm虚拟机拥有虚拟内核。（完全虚拟化需要虚拟化内核，然后通过真实内核进行命令执行，而半虚拟化只需要把系统调用通过真正内核执行，其他可以通过更高效的方式执行）。一般配合qemu虚拟化其他设备，libvirt管理虚拟机。OpenStack建立在这套虚拟化基础之上。
而docker则是基于linux的LXC容器基础，通过cgroup划分硬件资源，namespace划分进程空间，实现资源和进程的小隔间。同时通过桥接，host等方式使用网络，使用unionfs实现文件存储。
cookie和session区别我直接回答还没学计算机网络所以不知道
面试官说你在知识深度和广度方面都需要加强阿里希望招对技术专精的人
过2天后状态变成已回绝不亏确实自己水平不够
1.介绍一个比较熟悉的项目，问项目具体细节，挺多
2.说一下hashMap的底层，除了数组+链表，还可以用什么数据结构实现hashMap
空间复杂度不为11归并排序，复杂度是Onlogn，无论序列是否有序，都要全部扫描一遍、并且需要额外数组，空间复杂度为On；2快速排序，复杂度是Onlogn，partition方法复杂度是on，递归复杂度则是logn，并且对于每个数的一轮paritition都需要额外空间，而递归情况下放大了空间使用，也就是O（nlogn）的空间复杂度。快排在有序情况下复杂度变为O(n2)，因为每次递归分为1和n-1，需要n次递归，所以复杂度为O（n2）。3基数排序，根据位数决定。4计数排序，桶排序，都需要额外数组，复杂度为O（n）。
稳定性：情绪不稳定，快些选一堆朋友来聊天吧。快速排序，选择排序，希尔排序，堆排序，都是不稳定的。
4.堆排序和快排的区别和应用
1堆排序用于海量数据找前k个数。
2快排主要用于小数据量乱序数据的排序。
3而归并适合小数据量的任意序列排序。
5.进程和线程的区别
6.进程间的通信，线程间的通信五种Java并发工具，原生线程方法
7.TCP和IP的区别
8.为什么TCP是可靠传输的
1滑动窗口实现了有序传输，确认传输，超时重传等机制确保可靠性。2连续发送和确认提高效率，缓存数据包提高效率。3检验和保证正确性。4拥塞控制避免网络拥堵。流量控制保证收发速率合理
importjava.util.Scanner;publicclassTimel{
privatestaticScannerin;
阿里技术二面:
1.问了下部门意愿，深圳阿里(国际部)or广州阿里(文娱部)，面试官是深圳的，我也答了深圳
2.做过什么项目，简单介绍一下(ssh,ssm)
3.为什么选择Spring(把优点说了一遍)ioc和aop
4.你觉得Spring设计得最好的是？(答IOC,AOP)
5.分别谈谈ioc,aop的底层原理(反射机制，动态代理，具体继承的类实现的接口)反射机制进行实例化，ioc让类只依赖接口，不依赖实例，实现了依赖倒置，并且通过配置文件配置实际对象，完成了对实际类型的解耦，只对接口依赖。
动态代理实现了aop。jdk动态代理可以代理实现了接口的类。cglib可以代理任何类。
6.聊聊数据库的事务(acid,4个隔离级别，底层实现:加锁)
mvcc和加锁。
7.可重复读隔离级别为何出现幻读(InnoDB的行级锁与表级锁，解决方案)
可重复读一般只加行级锁就可以了。所以不能避免插入产生幻读，可以使用next-keylock这种锁来避免插入，避免了幻读。
当然也可以使用MVCC，判断版本号是不是比自己早，就不必读取这部分数据了。
如果用序列化级别实现，则要求所有事务操作串行化，也就是使用表锁，这里用的是读锁。
8.谈谈乐观锁，悲观锁(mvcc,版本号)
mvcc
9.介绍一下tcp握手过程
注意syn和SYN的区别
10.介绍一下Java并发包(并发容器，同步设备，原子对象，锁，fork-join，执行器，详细介绍了concurrentHashmap，Countdownlatch的底层实现及应用场景)
1并发容器：chm。写时复制容器，跳表。
2原子基础类型，原子引用。
3Lock，读写锁，内部基于AQS
4fork-join工作窃取，每个线程处理自己的一个队列，处理完了找别人拿，fork出来额队列放到公共队列中，等待执行。
5执行器，实现类一般是excutors的工厂方法，也可以自定义threadexcutor。
6chm的帮助扩容机制，原来单线程变为多线程。countdownlatch底层用aqs的共享锁模式实现。
11.分别介绍一下NIO,AIO,BIO(非阻塞，同步非阻塞，阻塞)
BIO就是直接使用io流交互，操作都是会阻塞的。
同步一般指的是线程阻塞在系统调用上。这个阻塞是不可避免的，除非内核支持AIO。
阻塞和非阻塞指的是使用线程阻塞等待io就绪还是线程轮询方式等待。
NIO包括channel和绑定的buffer，channel可以管理多个socket，socket可以复用buffer。使用selector注册socket事件，使用key遍历就绪事件，执行IO操作。我们可以开启一个线程轮询key，而不需要进行阻塞，这就是IO的多路复用，多个io请求复用一个selector，复用一个buffer。底层当然还是epoll。
AIO就是让内核完成IO操作，我们只需要注册回调函数即可，内核完成io操作后会进行通知。
12.同步和异步的区别，同步的实现原理(加锁，Java种锁的底层实现，AQS,CAS)synchronized同步，使用操作系统的mutex锁。其他线程不能进入该代码区，需要切换到内核态。
lock使用了AQS的state实现，采用cas加等待队列的方式模拟锁，并且也会用到同步工具类进行线程阻塞。
14.数学测试题:如何快速计算出7^128在计算机内占多少字节(取8^128得131位，再换成字节，面试官没给结果，不知这样算对不对？)
15.在学校成绩怎样(答了还行，面试官继续问具体情况，再答绩点，综测均第一………⊙﹏⊙我想低调的…)
16.英语水平怎样？(答了四六级分数)
17.口语怎样？(答一般，从环境因素客观解释了原因，说目前看文档没有问题，口语只要有环境有决心去练相信可以掌握，表现出学习的态度)
18.有什么想问我的(问了技术学习建议，面试官还是说(阿里)重视基础，要能阅读源码解底层原理，其他项目或实践经验都是加分项)
19.面了40分钟
跟一面一样，没有任何预兆，在上课的时候打来了。整个过程感觉面试官很匆忙，听我的回答很多都只听了一半就问下一个问题。不多说了，直接上问题：1.自我介绍
java7和8的新特性(居然忘了默认方法。。)函数式和lambda
optional判空
接口的默认方法
日期api
集合类的流式api
更新jdk，比如chm和hashmap。
删除永久代，增加元数据区。
ThreadLocal本质是一个hashmap。内存泄漏解决
FullGC原理一般起因是younggc不能解决问题。younggc+oldgc。触发原因可能有，堆空间不足分配对象，晋升失败，存活区空间不足等。
AOP
Future类干嘛的
接收callable的返回值，futuretask则可以一人分饰两角。
3:15分时针分针的夹角度数因为15分是1/4,3点到4点之间前进的角度是1/4*1/12=1/48所以三点15分时针的角度是3*1/12+1/48=13/48。两者差距是1/48,360*1/48就是7.5度
static方法和对象方法在同步的时候的区别static是类方法，与对象无关。
从大文本中找到自己名字的数量(楼主回答kmp，面试官说java中有个很简单的方法可以解决。我：难道正则？面试官：。。)
mysql连接查询
select*fromt1wherea.t=b.t
项目的各种问题
1cap2base3一致性协议4一致性算法paxos和raft，zab5分布式缓存，session，消息队列。6负载均衡，分布式数据库，hadoop，zk。7云计算，大数据。
红黑树(凉凉。。)特性，调整。
相对其他人的优势
1学习能力和学习方法2规划和坚持3主动性
总结：因楼主是双非而且非科班，算法这方面的东西太弱，红黑树只是听说过然后知道在HashMap中有使用。。而且楼主做的项目比较小，面试官对项目这块不太满意。总之，感觉凉凉。。希望各位加油！！！
双非二本软件工程专业，面的是菜鸟网络。这一个月都在面试，终于把技术面完了。就等HR了，革命尚未成功。加油先留图，以后再发面经。有什么你可以留言，我晚上有空会一一回复的。
阿里：一面：简单问了问多线程，之后怼项目问：支付宝回调时回传失败如何处理答：订单支付根据订单id更新无问题，充值生成id防止重复充值
每次支付生成一个新id，只能支付当前id对应的订单，否则支付失败。所以如果支付成功但是回传失败，再次支付时订单号和支付对应id不同，不会完成支付。
问：如果回调后本机服务处理过慢支付宝又回调怎么办答：使用分布式锁
如果本机服务处理过慢，导致支付宝再次回调，可以使用幂等性接口。
问：分布式锁怎么实现？答：mysqlrediszookeeper
1mysql把某条记录更新为1，解锁时更新为0，可能更新失败，导致无法获取锁。
3zookeeper在目录树下新建一个节点即可。问：找一个说下答：redissetnx
问：获取锁挂掉怎么办答：setnx时设置过期值
问：脑裂怎么办答：存储获取锁的对象，恢复后检查持有锁的是否为自己，不是则回滚
redis脑裂可能导致两个master同时出现，应该通过增加心跳链路的冗余来保证心跳可靠。
问：你项目中token怎么防止别人攻击认证系统答：jjwt可以验证是否为自己生成的，不是则不去查询redis
问：具体原理是啥答：不会，告辞
问：redis缓存了解么？答：没用过但是了解
了解过，lru，过期。
1查询验证，过滤部分查询。
菜鸡加面，简称菜面（太菜才会加的面，一面多线程那块出了个低级错误）在线编程，多线程轮流输出，提交后面试官提了个问题，解决了后结束
join大法好
二面：问：mysq使用多个索引的查询怎么运行答：and交集
问：or呢？答：只知道or会出问题不知道为啥（大脑一片空白，实际上是or带了非索引会出问题）
or如果使用了非索引字段则整个查询都不会走索引。
前缀匹配索引不要求where条件的先后顺序，只要求出现就可以
问：订单id量大怎么解决答：消息中间件缓冲，分奇偶生成id，分片生成id（实际为事先生成好）消息中间件削峰。
问：尬聊三连发1.什么样能成为一个好的程序员1技术基础扎实，对新技术有热情。
2对整体业务，架构要有比较好的认识，要深入理解自己的技术栈。
3重视协作，重视质量和迭代效率。2.问题在同事间出现分歧怎么解决协商3.你认为同事会希望你成为一个什么样的人能够独当一面，懂技术也懂业务，能协作，易交流和沟通，有责任感。
尬聊三连加上10天没三面消息，基本gg，状态永远停滞在面试中
三面：早上还没睡醒莫名其妙来的三面。。都快一个月了。。问：自我介绍答：blabla
问：java用几年了答：两三年
问：看你知道并发，进程间交互方式了解不？答：匿名管道，命名管道。。。。。bla1管道（半双工），消息队列（存储消息，通知进程），信号量（封装好的管程），socket，共享内存，
问：线程的锁有啥答：lock类，syn锁，volatile可见性，原子类，syn的实现是（面试官：打住，打住）
问：final的用法答：类，方法，变量
为了修补这个漏洞，JSR-133专家组增强了final的语义。通过为final域增加写和读重排序规则，可以为java程序员提供初始化安全保证：只要对象是正确构造的（被构造对象的引用在构造函数中没有“逸出”），那么不需要使用同步（指lock和volatile的使用），就可以保证任意线程都能看到这个final域在构造函数中被初始化之后的值。问：jvm了解么？答：还行
另外还可以设置阈值，设置回收器，设置永久代大小（1.8不行）
问：jvm有回收方法了为啥还会内存泄露答：堆泄露，栈，方法区分别举例
静态容器持有大量对象不释放。threadlocal内存泄漏。数据库连接池，监听器，lock等情况。
问：附近的人怎么实现答：地图分区块，用户存区块，查附近人按区块查，最多跨4个区，用户按区设置索引（其实是geohash，可惜之前没准备）
geohash，redis
问：项目是个啥？答：小型电商项目，卖建材的
问:你写的接口端开发，你是做啥的？答：于安卓和ios交互的全部内容，全部用json返回值，登陆状态用的token
问：用户密码怎么存的？是明文？答：md5。。
最后说最后会4月末给消息，过不过都会标明，等呗
2.项目中的excel处理操作如果遇到大文件内存容量不足怎么处理。(内心有点崩溃。。平时用的时候根本没考虑这么多，就说了下自己的一些想法)
3.jvm内存，堆栈以及垃圾回收
4.类加载机制，如果程序自定义一个java.lang.Object会发生什么不会被加载
5.乐观锁与悲观锁
6.线程池实现原理
7.HashMap与ConcurrentHashMap的区别
8.快排
9.最短路径问题
10.2017的2017次方的最后一位数是什么
11.为什么不想读研
12.什么时候能去实习
大概就上面那些，总体感觉一般，有些问题没回答好，感觉凉了。。
蚂蚁：“晚上不行，要不改天”一听到“改天”就觉得大事不妙，算了，硬着头皮上吧
蚂蚁：“师兄，等下，我穿下衣服”我：“好，我五分钟后再打给你”
（五分钟后）蚂蚁:“自我介绍下”我：blablabla
蚂蚁：“第三个项目是自己做的还是给老师做的？”我：blablabla
蚂蚁：“从下面两个项目选择一个最满意的”我:我选择的是cord，意义非常大，但是真的不好展开呀，掉沟里了。blablabla蚂蚁：“说说dubbo的工作方式”
我：（不是很熟悉）就从最基本的dubbo+zookeeper说起，又说了容错机制蚂蚁：“dubbo为什么会有这种容错机制”蚂蚁&我：因为场景需要吧12dubbo的容错机制有几种：1可以快速失败然后报错2也可以多次进行重试。
蚂蚁：“openstack与docker的区别”我：blablabla
OpenStack基于Linux的kvm虚拟机实现，配合qemu和libvirt完成虚拟化。
docker类似Linux的LXC容器实现，使用cgroup隔离物理资源，使用namespace隔离进程。
蚂蚁：“虚拟机启动流程”我：回答的比较表层，说实在的，我也想知道底层是怎么实现的OpenStack的cinder，glance，neutron，nova搭配使用。
首先通过master执行api，novamaster中的novasheduler会执行机器调度，找到合适的物理机，然后nova调用libvirt的api启动kvm虚拟机，同时使用qemu虚拟化硬件设备，完成一台虚拟机的初始化。同时为其分配存储，安装镜像，以及配置网络信息等。蚂蚁：“说说你在cord项目组的作用”我：blablabla
蚂蚁：“为什么这么晚投简历呀”我：怕当炮灰
蚂蚁：“你有什么问题要问的？”我：blablabla
阿里一面:1.学过哪些技术知识呢？
2.说说接口和抽象类的区别(语法，设计，跨域三方面)1成员2用处（继承，实现）
3.怎么判断两个对象是否相等？(名称和类加载器)全限定名和类加载器
4.==和equals的区别(比较方式)
5.排序算法有哪些呢(分类说，插入，选择，交换，归并，基排)
6.说说归并的算法过程(先划分，归并，递归实现，把过程理清)
7.知道先序，中序，后序遍历吗？(把算法过程说一遍)
9.谈谈JVM(从javac编译4阶段:词法，语法语义，生成，到类加载过程:双亲委派:加载，验证，准备，解析，实例化，实例化先谈堆分区，再说JVM内存结构，然后到GC,GC算法，触发条件，晋升，YGC,CMS过程实现，可达性分析等等，把整个体系说完后面试官肯定了一句说理解得不错…)
1编译成Java类，需要经过语法，词法分析，生成class字节码。
2jvm加载类，经过验证，解析，初始化等过程，先把类加载到方法区，再在堆中实例化一个Class对象。
3GC主要用于回收无用对象,GC年轻代满时触发ygc，晋升失败或者老年代满时触发fullgc.
4年轻代停止复制，老年代标记清除。cms初始标记要stw，标记gcroot（局部变量，本地内存的对象，静态变量等），然后并发标记，接着stopworld重新标记，最后并发清除，由于cms不整理，会有内存碎片。并且，cms是并发清除，吞吐量较低，但是保证延迟较低。
10.做过哪些项目？用过哪些框架和技术呢？(SSH,M,Redis,Netty)
11.看过spring源码吗？(把容器启动过程说了一遍，xml解析，bean装载，bean缓存等)
12.说说AOP实现原理(动态代理:jdk,cglib，分别用了哪些类或接口)
13.事务的实现原理？(源码)
14.说说四层网络模型(每层的协议及应用)
15.谈谈tcp,udp的区别，分别有哪些应用(可靠，面向连接，首部)
16.说说tcp三次握手过程？
19.面了50分钟左右
reactor线程模型，一个线程组负责接收请求和包装事件，然后把异步回调处理器注册到事件轮询器selector上，当epoll事件就绪时，另一个线程组负责调用回调方法完成io处理。
2、IO流是怎么处理的？使用bytebuf缓冲进行处理，该缓冲支持零拷贝，可以复用header和body。
3、netty里面boss线程池和work线程池是怎么交互？boss注册事件，通过事件队列，worker线程监听事件队列的事件，到达时取出事件执行即可。
4、项目里面有分布式管理，分布式是怎么体现的？这个zookeeper是起什么作用？zookeeper如何管理服务器？多个服务分别部署。服务注册和发现中心，配置中心。zookeeper维护服务集群的配置信息，完成注册和发现，进行心跳检测。
5、客户端怎么是如何找到服务器的？通过zk
6、为什么选择netty，有没有和其他开源框架做过比较？mina
然后就是一些细节问题了，项目也被批了一顿，后面就是基础知识了7、问我string源码阅读过不？简单的介绍一下string底层？final修饰的char数组，地址不能改变，但内容可变，只不过没有提供方法操作。
8、string对象在JVM里面存储的位置？堆，以前可能在方法区的常量池
9、object类有哪些方法，分别介绍一下？线程方法，finalize和clone。等略
10、进程与线程的区别？
11、线程池的概念，里面的参数，拒绝策略等等？
12、悲观锁、乐观锁？
13、synchronized和CAS？
14、hashmap源码，着重讲了下put和get的实现？
1归并，复杂度是On。
2算出两个数组总长度，然后从后往前，由于两个数组是有序的，当大数组的当前数字比小数组大，则直接放进去，如果比小数组小，则放小数组的数字，然后下标左移，然后依次类推，只需要一次扫描就可以放完。复杂度是0（n），空间复杂度也是on，n为大数组长度
总体前面的项目问的东西比较多，问的基础知识还是很简单的，面试官人比较好，希望还有后面的面试，阿里，人生第一面啊。
/*************************一面************************************/1.设计原则和设计模式(简历第一条写的就是熟悉面向对象设计思想，坑了自己)，你用过哪些东西能体现这些设计原则；
我们可以用另外一句话来总结这些差别：使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，而装饰者能够在运行时递归地被构造。13.javaio、nio，nio有哪些好处，io有哪些坏处；linuxnio用什么函数实现，nio是同步还是异步epollepoll的create,ctl，wait.对于轮询线程来说非阻塞的，对于底层的receive函数来说，它仍然是同步的阻塞操作。（unix网络编程）4.如何实现CPU上下文切换，那么有哪些函数导致线程切换
进程切换进行进程切换就是从正在运行的进程中收回处理器，然后再使待运行进程来占用处理器。这里所说的从某个进程收回处理器，实质上就是把进程存放在处理器的寄存器中的中间数据找个地方存起来，从而把处理器的寄存器腾出来让其他进程使用。那么被中止运行进程的中间数据存在何处好呢？当然这个地方应该是进程的私有堆栈。让进程来占用处理器，实质上是把某个进程存放在私有堆栈中寄存器的数据（前一次本进程被中止时的中间数据）再恢复到处理器的寄存器中去，并把待运行进程的断点送入处理器的程序指针PC，于是待运行进程就开始被处理器运行了，也就是这个进程已经占有处理器的使用权了。
yield，wait，sleep会导致线程切换。
5.说说你知道的锁，乐观锁悲观锁
6.atomicinteger如何实现，什么是CAScompareandset；
7.reentrantlock的reentrant是什么意思可重入8.jvm内存分区
9.垃圾回收器，CMS垃圾回收器相较于其他垃圾回收器有哪些优点优点：并发标记和清除，效率高，利用多核速率。缺点：不整理内存，导致碎片，且吞吐量不高。
10.类加载器中方法有哪些，defineClass方法是啥findclass用于自己加载类，defineclass把byte流定义为一个类并加载。loadclass依据双亲委派加载，要破坏就要重写loadclass。
11.jvm如何设置新生代、老年代大小，如何设置新生代8:1比例，jvm调优的方法，jvm内存是不是越大越好8:1:1。xmn和xmx，xms。两个相减就是老年代了。不是越大越好。调优方法：1确定指标，比如吞吐量，延迟，以及qps。
2压测，使用jmeter，loadrunner等工具压测，并且监控服务状态。比如visualvm。
3确定瓶颈，gc（gc日志，jstat）还是内存问题（jmap，mat等分析内存溢出和泄漏）。或者是代码问题（jstack定位线程，tprofier定位方法。）
4更改参数配置，内存更改配置，更换gc回收器，直到达到指标为之。
12.分页查询，mysql索引实现limit20，10
14.tcp三次握手，tcp长连接短连接
15.MySQL数据库优化
17.spring事务如何实现，哪些配置方式
18.用了spring的哪些东西，有什么好处
19.linux文件结构
1inode节点保存除了文件名以外的所有信息，一个文件名指向一个inode，inode保存实际存储位置。2目录也是一种文件，也指向一个inode，但是这个inode存的是文件名到inode的映射关系。
硬链接指向同一个inode，软连接指向绝对路径20.CGLib如何实现代理类继承实现类，使用asm框架生成字节码，传入实际对象，代理类包含原实例方法和增强后的方法。/********************二面****************************************/1.实验室研究内容，给面试官讲明白（面试官说要看你对一个内容的了解程度，看你的潜力而不是现有知识的掌握）
2.项目（我简历上没有项目，问我最近在做什么，关于这个扯了很久）
3.知道哪些orm框架除了mybatis（不了解），mybatis实现（源码）
3.mybatis事务，spring事务如何实现，本地事务，分布式事务
4.spring你知道的都说一下，为啥不用springboot，对新技术怎么看
5.设计模式有哪些
6.加密（越多越好，然而我只知道MD5），优缺点，MD5怎么破解，有没有想过加密的原理md5,sha,rsa
7.javaio，nio，aio，举例子
8.jvm内存，如何定位jvm问题，如何优化，OOM四步走，压测+监控。工具排查，参数调优。
9.哪些情况可能cpu100%，如何解决代码出现死循环。并发量很多，cpu忙个不停。/***************************************重要**********************************/
1.简单自我介绍一下
2.项目（聊的比较多，主要描述自己负责的模块和某个功能的实现细节）
3.JAVA数据结构（HashMap等底层原理）
在牛客网上获取到很多知识和信息，现在反馈一波，希望能对广大找实习的同学有所帮助。个人情况：EE方向渣硕，二月末内推了阿里集团某部门Java岗，约三周完成了所有面试。
面经如下：
一面（简历评估）：1、自我介绍
2、TCP与UDP的区别
3、TCP三次握手说一下（把流程说一遍，这里以为会继续问为什么不是两次或者四次，结果没有）
4、看你项目用到线程池，说一下线程池工作原理，任务拒接策略有哪几种
5、进程和线程的区别
6、ArrayList与LinkedList的区别
7、线程安全与非线程安全集合说一下，底层怎么实现的（hashmap，concurrenthashmap）
8、Java内存模型，方法区存什么
9、数据库事务隔离级别说一下
10、synchronized和lock区别，可重入锁与非可重入锁的区别
11、看你的项目用了悲观锁和乐观锁，说一下区别
12、算法题：圆圈中最后剩下的数字使用余数法实现，也可以使用链表实现
二面（部门主管）：1、说一下Spring的IOC和AOP，底层什么原理
2、动态代理有几种，Jdk与Cglib区别
3、数据库三大范式
4、左连接和右连接说一下，内连接呢
5、数据库索引有几种
6、数据库引擎你认识几种，innodb和myisam区别，你的项目用到哪个引擎
7、若hashcode方法永远返回1会产生什么结果
8、Error与RuntimeException的区别
9、引用计数法与GCRoot可达性分析法区别引用计数法为每个对象的引用计数，可能导致循环引用时对象无法释放。10、双亲委派机制说一下
11、算法题：找出一个数组中第100个小的数字（堆思想解决）
三面&四面（这里合在一起写了，分别是部门A总监与B总监，本以为三面完了就是HR面，结果隔天B总监打过来说补一轮技术面~~三面和四面更多的是问项目，基础问得不多）：1、volatile关键字作用可见性和原子性
2、看你项目用到策略模式和工厂模式，说一下区别策略模式可以配合策略实例。工厂模式用于获取实例。
3、模板方法模式
模板方法就是一个抽象类模板，规定好了一个方法执行模板，里面有抽象方法或实际方法，并且有部分抽象方法需要自己实现。
4、开闭原则懂吗，说一下
不要修改源代码，而是通过继承，组合等方式来复用代码
5、NIO说一下你的理解
IO多路复用
6、AtomicInteger底层原理
cas
7、CAS机制会出现什么问题
1ABA问题可以通过版本号来解决。
3只能保证单个变量的原子操作AtomicReference类型可以保证一个引用的操作是原子性的，从而可以保证引用对象内部的变量也是原子性操作。
8、还用过并发包哪些类
10、分布式理论懂多少，说一下（这里我说了CAP，Base，paxos）1cap，base
2一致性协议2pc，3pc。paxos，raft，zab。
3分布式事务及事务消息。分布式锁实现，分布式全局id生成器，负载均衡，数据库的分库分表。
4分布式session，分布式缓存，分布式数据库hbase，消息队列kafka。
5分布式服务，微服务，容器和k8s调度系统。
6分布式计算平台Hadoop，其中的分布式文件系统hdfs，分布式计算框架mr，spark和storm，调度系统yarn。
11、分布式事务有了解吗
理论：2pc，3pc实践：TCC，rocketmq事务消息，自己实现事务消息
12、RabbitMQ消息队列丢失消息，重复消费问题
不断重发。消息记录
2、有参加过算法比赛吗
3，Redis和memcached
redis的数据结构更丰富，并且有分布式方案，支持持久化
4、Redis集群宕机，数据迁移问题
rdb全量备份+aof增量备份，设定间隔为一秒，大部分数据已经备份完成。
5、看你项目用到Springboot，那有用过Springcloud吗
没有。springcloud提供更加多的微服务支持。而dubbo主要专注于服务治理，而不像springcloud主要是构建生态。当然dubbo提供了扩展点让使用者来实现这些扩展功能。
6、RPC说一下
rpc一般基于tcp协议实现，自己构建上层协议，比如dubbo，hession，同时使用不同的序列化协议比如thirft，protobuf等。
而基于tcp的编程则使用netty完成，一来是可以使用NIO的io复用机制达到优秀性能，而来使用netty编程简化了代码，以及提供了更好的扩展性。
7、说一下你对微服务的理解，与SOA的区别
微服务就是把soa服务更加细粒度的拆分，独立部署，快速迭代，功能独立。微服务框架一般需要包含：1同时具备服务网关，负载均衡的功能。2服务快速部署和支持伸缩，服务注册与发现，服务配置统一管理。3心跳机制，容错机制。4熔断，限流等特性保证一个服务宕机不会影响整体服务。5服务监控，服务的链路跟踪检测，保证能够快速定位问题所在环节。6服务灰度发布，服务的降级7另外还可能包括任务调度功能，类似k8s的提供。
六面（HR面）1、平常怎么学习的
1最早是视频2后来主要是看书3然后开始看一些博客和社区4接着自己写一些博客，demo。
2、兴趣爱好运动，健身，旅游。
3、觉得自己前面几轮面试怎么样还可以吧
4、除了Java还研究过其它什么技术（我说AI，区块链）
分布式理论。
大数据，云计算。
5、跟我介绍一下区块链~
捞
6、怎么看待国内区块链的发展
7，跟我说一下你认为最具有挑战性的项目
网易那个吧
8、问我还参加了什么公司的招聘
京东，百度
9、如果有网易游戏，腾讯，阿里的offer你会选择哪个
看部门和岗位情况，具体城市等。因为阿里是Java系，会倾向选择阿里。
10、英语10分钟交流（瞬间懵了，这里估计是部门有英语交流要求）
面经如上，有一些问题确实想不起来了，请谅解。总体来说面试难度没有我在其它大佬们的帖子看到的这么难，都是基础加项目，另外也可能是因为我的心态一直比较好，所以面试发挥还算OK吧~HR说面试结果会在4月份中旬出来，估计是进备胎池了，慢慢等吧，继续复习，准备其他公司招聘。
有后续会继续更新~
阿里一二面面经一面大约是3月6、7号的样子，人生第一次面试（电面）说实话很紧张
关于项目：简单的问了问，然后问我高并发怎么优化，这方面不会啊然后问我了解HashMap么
接下来我就使劲儿，说了一下HashMap还有ConcurrentMap区别和各自的实现，感觉说了好久
面试官问我了解JVM么，可是他都不提问，就让我一直说，一直说
从各个分区的特点，各个回收机制，还有各个垃圾回收器的特点balabala还有很多然后高潮来了
我一个人说很尴尬啊我轻轻对着手机说了一声喂？面试官说我在呢你说吧（贼尴尬）
乐观锁和悲观锁了解么，还有Lock和Sycrounized的区别（因为这块还没复习，没说上来，接下来的几天把各个锁复习了一下，终于可以跟美团面试官谈笑风声哈哈哈我在搞笑啦菜死了）
怎么解决秒杀，瞎说的，不太会1前端页面控制，请求过滤。2服务负载均衡，集群部署服务，消息队列削峰，使用缓存处理一部分请求，最后再到达数据库。
Spring事务管理说了一下但是说的不好
传播机制，required就是需要开启事务，never就是不用事务，support是支持事务但是不一定需要，如果有的话就在事务上下文中运行。
SpringIOC和AOP这个感觉都问呢
有啥想问他的么
一面大概一个小时
正则表达式就是一个自动机，复杂度为O（n）就是各种项目扣细节，我面试完好好的把项目琢磨了个通透，就是讲的一定要让人听懂。
ps：二面以后，我也不知道凉没凉，问了面试官说三面可能性大，等了一周了又去问，说是下周有希望，感觉可能是个备胎吧，就这感觉
楼主3月9号找人内推哒，3月14号一面，3月16号二面，没做在线测评和编程，发出来面经攒一波人品～
嗯，楼主渣硕(╥_╥)，现在在美团实习，背景。
一面:1.实习项目
结合项目问了幂等，消息队列的一些实现
消息队列实现：1rpc的实现（协议，序列化，网络编程，服务治理）2数据持久化。3zk维护消费关系，维护配置和心跳。4消费确认，消息有序，消息不重复的问题解决5kafka的存储是分布式的，消费者可以是单播和广播。6推拉模式的区别。
2.悲观锁和乐观锁的原理和应用场景
读多写少。写并发量大。
3.mysql行锁实现
索引加锁
4.多线程有没有实践过
结合项目说了线程池和callablefuture15.volatile底层原理
6.concurrenthashmap原理
7.hashmap初试容量
8.linkedlist&arraylist
9.一个在线编程
负载均衡的一个实现，服务器资源分配70%20%10%反正我只会写轮巡，还有bug，我要哭死了。。
加权轮询算法。1做一个权值到ip映射的map2权值的比例根据服务器资源分配来安排。写成数组[1,1,1,1,1,1,1,2,2,3]3然后轮询
一面问问题20分钟磨洋工写代码，写完了面试官不见了，我在电脑前尬坐了30分钟，才发现有聊天功能可以跟面试官说话，他开会开了静音，好尴尬啊。。
二面:1.自我介绍
2.作为一个女生有什么职业规划？你看很多学计算机的女生都转行了（黑人问号）
3.hashmap原理
4.事务的特性及理解
5.实现一个LRU缓存（楼主忘了linkedhashmap怎么做了，只记得o（n）的方法，）重写removelast方法，然后返回值是size>cachesize，当超过size时就会被替换了。并且替换的是链表头，也就是lru。
如果要自己实现了lhm，则需要重新写一个hashmap。再写一个链表把节点串起来。6.设计模式用过吗？结合项目说了工厂和职责链，又问了单例和单例构造函数的注意点工厂生成实例。职责链则可以让请求自动走完链条，复用了职责链，并且方便扩展操作。
7.在线编程两个有序数组的合并，就写了常见的归并排序。。
二面也是问问题20分钟加编程20分钟，最后面试官提醒我找一下bug，然后就结束了。。
总的来说我的面试为啥这么简单&&每次都要写代码呢。。哭，感觉要没戏了，大家看看就好~
0.自我介绍和技能栈，平时怎么学习的
1.说说快排和归并。
2.快排为什么快。（突然脑子懵了）
3.从数据库中主键字段取出上万条数据，用哪种排序好？主键排序。
4.TCP/IP协议，为什么TCP是可靠传输，为什么不是4，5次握手？滑动窗口
5.HashMap底层，put，get详细过程，如果重写equals不重写hashcode会怎么样？
7.B+树介绍，红黑树介绍，B+为什么适合做数据库索引
8.ArrayList和LinkedList，适用场景
9.具体说说JVM内存模型，GC回收算法，可达性分析。
10.给一个数，快速判断是否为2的N次幂。（想了半天最后还是没弄出来）
神仙题最快速的方法：(number&number-1)==0
11.你有什么想问的吗？（我问了那边现在主要做的业务）
业务，技术栈
首先感谢阿里给的面试机会（其他的简历都泡水两周了），投的是菜鸟java岗，第一次面试紧张，口齿不是很清，面试官耐心引导，非常nice，大家一起加油吧。
—阿里巴巴一面(37分钟)没有让我自我介绍,直接进入了正题1.对面向对象的理解
面向对象为我们编程带来了什么好处
对封装,多态,继承的理解
Java中哪些集合是线程安全的哪些是线程不安全的
如果A类要访问B类中的字段,要怎么去设计1继承可以访问非私有字段
2引入实例可以访问非静态非保护字段。
3通过反射可以访问全部字段。
在多线程中,A类有一个静态成员变量,如果A类在运行期间修改了它,B类是否能知道可以。静态变量存在运行时常量池，也就是方法区中。
在多线程程序中,怎么保证线程安全
Exception,Error和Throwable的异同前两个继承自后者，需要实现构造方法，并且继承后者的方法。
在什么情况下会触发FullGC0system.gc方法可能会触发1大对象和数组分配失败，老年代空间不足。
2永久代内存不足。
3cms的晋升失败和并发分配失败。
4统计minorgc晋升大小超过了老年代空间
在什么情况下新生代中的对象会被移动到老年代(永久代)大对象，晋升
在使用Mysql时是否自己建立过索引(我回答没有)
createindexon列名、默认聚簇索引，使用客户端工具。12.那分别给我介绍下数据库中聚簇索引和非聚簇索引
在一个系统中,如何去做整个Exception的设计需要设计层级，最高层的exception，然后设计子exception，这样高层可以捕捉底层错误，或者底层封装错误抛给高层。并且高层exception要继承exception或runtimeexception，后者一旦发生程序就会中断。。
定义异常：必须是自定义类继承Exception。
继承Exception原因：异常体系有一个特点：因为异常类和异常对象都需要被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中的独有特点。只有这个体系中的类和对象才可以被throws和throw操作。
throws和throw的区别：throws使用在函数上。throw使用在函数内。
throws后面跟异常类，可以跟多个，用逗号隔开。throw后面跟异常对象。
自定义异常时：如果该异常的发生无法继续运行下去就让自定义异常继承RuntimeException
在系统设计中,如果我对某种类型的Exception感兴趣,设计一个方案,使我能够对其进行监控另外总结一下运行时异常与非运行时异常的区别：运行时异常是RuntimeException类及其子类的异常，是非受检异常，如NullPointerException、IndexOutOfBoundsException等。由于这类异常要么是系统异常，无法处理，如网络问题；要么是程序逻辑错误，如空指针异常；JVM必须停止运行以改正这种错误，所以运行时异常可以不进行处理（捕获或向上抛出，当然也可以处理），而由JVM自行处理。JavaRuntime会自动catch到程序throw的RuntimeException，然后停止线程，打印异常。非运行时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类，是受检异常。非运行时异常必须进行处理（捕获或向上抛出），如果不处理，程序将出现编译错误。一般情况下，API中写了throws的Exception都不是RuntimeException。
1捕捉特定类型exception并且记录日志。2监控实例
二面面试官问了我之前做的一个项目（安卓的），然后让我思考有什么不足之类的，脑子很懵，语无伦次，确实很多东西没有思考过，然后就凉凉了，但是面试官超级好，给我上了一课啊不亏哈哈哈，帮面试官宣传下
====================================================================================================================================一面自我介绍，怎么学java的。
1.Object有哪些方法
2.你刚说的clone浅复制和深复制有什么区别，举个例子
深拷贝会复制实例内的成员变量对应的对象，浅拷贝只会只会拷贝引用，指向同一个对象3.equals如果不重写hashCode会怎样，举个例子，equals默认情况下是返回什么
4.容器了解吗，说下
5.hashMap的put方法说下，它是安全的嘛，举个例子，多线程同时put会有什么问题
6.怎么让他安全呢（我说了table,synchroniedMap,concurrentHashMap）,说下他们三个的区别
7.concurrentHashMap原理
8.内存泄漏，怎么防止，localThread
静态容器，连接池，监听器等组件。9.wait和sleep区别
10.wait应用场景
11.并发包下面用过哪些，我说闭锁栅栏和信号量，分别说说
12.消费者生产者模式怎么设计的，如果中间一个篮子只能放一个苹果，生产者和消费者各只有一个，怎么设计，如果很多线程又怎么设计
13.死锁什么情况下会出现，举个例子，怎么预防呢A,B加锁后同时请求对方的锁
14.A和B相互转账可能会发生死锁，设计程序避免这种情况不要用悲观锁，改用MVCC机制，当事务冲突时进行回滚
15.说下常见的数据结构
16.栈和链表的区别，你自己怎么设计一个栈，栈用在什么地方，举个例子
17.volatile说下用处，举个例子
18.有哪些排序算法，说下冒泡和选择
20.数据库一张表，有学生姓名，成绩，课程名，找到所有成绩大于80的学生
21.说下数据库的设计思想
22.JVM分区，分别干什么用的
23.Strings=newString(“abc”);在上面的分区中怎么玩的
24.说下垃圾回收机制，分代区域怎么分的
26.如何识别是同一个用户
27.session机制
29.一个反射机制写个工具类扫描一个包下面的类方法什么的是否符合java编写规范不符合
30.ArrayList和LinkedList的区别
2.数组和链表有什么区别
3.map，set，stack（太紧张了没听清）
4.hashmap读场景特别多，写场景比较少，改变策略
5.内存泄漏，如何定位排查dump分析。gc频繁，老年代剩余空间不足等情况。visualvm监控内存使用情况。
6.死锁
互斥，循环依赖，不可剥夺，请求和保持对对方资源的请求
预防资源分配图，有序分配资源
避免银行家算法
检测和解除通过资源分配图检测死锁，通过抢占，回滚，杀死进程来进行死锁恢复
7.除了java还学过哪些东西
8.问项目
9.有没有参加过编程类竞赛（没有）
11.有一份ip地址和地理位置的缓存（写一个方法）从内存和效率上考虑（目测已凉，人生中第一次面试太紧张了）
linkhashmap，或者用zset这样的跳表+hash的结果
一面简历评估（10分钟）面试官主要问了一些简历上边的实习时候做的项目，让我简单的介绍一下自己的项目。同时问做的什么研究，由于我大方向是网络方向，实验室的主要研究方向是分布式存储，分布式计算。可能面试官对于分布式不是很熟悉，这一部分我提了一下，就没再多问分布式的东西。
第一个项目是做大数据存储和检索的，主要问了大规模数据的存储，如何实现数据的存储，同时是如何设计关系模式的，使用的分布式架构是什么，具体的实现原理是什么。
关于检索方面，具体问了我如何实现的全文检索，以及如何实现数据的索引建立，以及如何实现特定名词的检索。然后就是第二个项目，这个比较简单，主要是做了一个web项目，也参与了部分前端的开发，问了服务端的实现springMVC。
后边主要问了数据库方面的问题，数据库的索引如何建立，数据库的存储引擎是怎么样的。操作系统方面问了进程和线程，进程与线程的区别以及如何实现同步，问了实现同步的方法，又问了synchronize，lock的区别，以及wait,notify等的区别。最后问了堆和栈的区别。
另一个是分布式文件系统，主要是项目中用来做底层文件存储的，怎么做文件的分布存储以及容错、一致性方面的问题。
由于我提到了多副本状态机，从而保证分布式一致性，面试官顺道就问了分布式存储中的一致性问题，让我详细讲一下raft算法，以及paxos与raft算法的区别。最后让我讲了目前项目中遇到的一个最难的挑战是什么，是怎么解决的。Raft协议比paxos的优点是容易理解，容易实现。它强化了leader的地位，把整个协议可以清楚的分割成两个部分，并利用日志的连续性做了一些简化：（1）Leader在时。由Leader向Follower同步日志（2）Leader挂掉了，选一个新Leader，Leader选举算法。
raft优势：简单，好懂，易实现。场景没什么太大区别.
然后开始问技术1.垃圾回收机制
2.事务的四个属性
3.HashMap和HashTable的区别
4.StringBuffer和StringBuilder的区别
5.服务器性能调优
6.SpringAOP
7.Mybatis和Hibernate的区别
8.手写程序造成程序抛内存泄露的异常
9.高并发处理
面试持续1小时15分钟面试官脾气温和，给我很多启发题目只答出来了表层，他往深了问，问我为什么要这么设计的时候蒙圈了，程序设计题也只想出一种解法，思路不开阔目测凉凉了……
1.什么点往南走1公里，往东走1公里，往北走。。。回到原点。
2.8个球，一个轻，天平2次找出来。
1先拿6个球称一次，找出轻的三个，如果一样重，则称另外两个。
2轻的三个中任取两个比，如果两个一样重，则轻的是第三个，如果不一样重，轻的就是那个了。
3.stringbuffer和stringbuilder
4.hashmap，hash冲突，并发下会造成什么问题
5.hashset怎么保证唯一性如果key存在就会替换，所以唯一性，
6.介绍concurrenthashmap
7.synchronize和reentrelock区别
13.线程进程协程
协程自带上下文。不需要切换cpu。所以自然是协程比多线程切换要快。
但是要利用多核cpu。还是得靠多线程来实现，因为协程是用户态的东西，内核线程则是内核态的东西，支持并行。所以一般使用多线程+协程的方式实现。
14.反射能取到一个变量的名字吗差不多就记得那么多25分钟，第一次面大公司啊。。
不能，只能取到类型。
面试开始：痛苦，不想多说。阿里不愧是阿里，问的很有深度，而且都围绕着项目来。
面试题目：自我介绍，巴拉巴拉大概四五分钟。开题让我介绍自己的项目，让我特别详细的介绍，包括项目的初衷，如何进行的设计，项目中出现的问题，怎么解决的，项目现在怎么样。提了一句项目中前端用什么，我说异步的框架，我不会，他问你知道Ajax嘛，我说我用过，没细问，不知道啥意思。
看我用了ActiveMQ，问我为什么用ActiveMQ，为什么不用其他类型的消息队列，我告诉他我不知道。ActiveMQ如何保证发送端和接收端能够发送出去和接收到，以及如何保证的安全性。卧槽？
看我用了MyBatis，问我#和的区别，为什么用的区别，为什么用不用#，我当时没想出来，告诉他一个是全文替换，一个是模糊匹配。后来说是防止注入攻击，然后我就马后炮了一下。
提到MyBatis，问我直到的数据的索引的数据结构，我说有四种，常用的是B，还有哈希索引，但是哈希局限性太大，不常用。问我知道B-嘛，我说知道，就问我什么用B-，我说MongoDB，然后他问我B和B-的区别，我和他说两个都是多叉树，区别在于一个非叶子节点上存数据一个不存，也就是说会影响高度。
问我知不知道volatile关键字，知道，就问我这个东西是干嘛用的，然后我把原理和他讲了一遍。问我多个线程如何按照顺序进行启动，我不造啊，我和他说我之前用过的方式都是Thread.sleep()，好尴尬。后来看好像是join，他以为我不知道这个关键字。
问我Spring用在什么地方，我就和他说每个地方都用，IoC和AOP，问我Spring默认是单例还是多例，我说单例，然后问我servlet是单例还是多例，我说是一个请求一个线程，然后居然答了多例，我肯定是疯了。然后问我知不知道ThreadLocal，我说再Spring里面见到过，问我作用，我说是为每一个线程复制一个对象的副本，问我线程安全吗，我说线程私有那肯定线程安全啊。
问我知道什么设计模式，我说单例、工厂、装饰者、代理、建造者、模板方法，他觉得太少了，我就说还有策略。问我单例的写法，我就举了饿汉和三种懒汉。问我GET和POST的区别，讲道理记不清了，只记得一个在请求头一个在请求体里面，然后觉得太少，就说在REST下，GET是幂等且耦合的，是获取资源的信息，POST是对资源进行添加。
问了两个简单的算法题，一个是查找链表倒数第k个节点，一个是判断是否交叉并且在哪里交叉，比较简单，装作自己没刷过这些题，还嗯了一会。
之后说数据库，我说MySQL，他问我视图，这尼玛是我最坑的一块啊，问我视图的作用，我说是保证安全，将其中一部分的字段提供，然后他问我确定嘛，然后我！改！了！我说是对使徒的修改就会将操作映射到不同的表里，相当于同时修改多个数据表。
确实修改视图会修改基本表
总结：感觉有点凉，最简单里反而没答上，绝望。我问要学习建议，他说没有；我问他你问的MyBatis和ActiveMQ我没深入了解，是不是要继续深入学习一下这方面，他说你毕竟也才用了一年，然后说了下#和$的问题；我问他说觉得怎么样，他说比最近面的其他人来比还可以，让我一周之内等消息。感觉有点凉。
先是介绍自己，我说了一下自己的情况，项目实习经历。问到我实习用到了什么框架，因为我们公司的不是开源的我就讲了讲大概的，说到rpc的调用，因为本身理解的不够透彻就直接说了这个不是很清楚。
说了它是nio传输。说到学校做过的项目，用到了struts2hibernate面试官问spring用了么，我说项目里没用，但自学了。
因为当时自学了，后来没怎么用，spring这部分大概知道怎么用的，知识细节确实忘了，面试官问到springmvc和struts2的区别，我就讲了struts是管理的action继承了actionsupport我们用的是xml去管理的，配置不太方便，springmvc是controller管理的，
使用注解，其实这两个都可以使用注解也可以使用xml去管理，然后struts2是基于filter实现的，springmvc是servlet实现的，然后问到了object的方法有哪些，一时糊涂只想起来了wait，问三次握手，记得细节模糊，答得不太好，问了点数据库知识，问我有没有用到having语法，答没有…记得的有这些。
全程问项目，准备的没问几个。1.数据库分库分表。2.索引为什么快。3.快排。4.jvm内存分布
总共面了60分钟40项目，项目是个小项目，但是优化各方面想的比较周全。但是也不排除他就是想找个理由把我挂了吧…..（面试官非常nice，第一次面试有点紧张，和我一样的小伙伴大家一起加油吧，比赛才刚刚开始，该有的offer一定会有的！）
自我介绍说说你的项目吧遇到过哪些问题，怎么解决的
maven中两个冲突包依赖其他包，怎么处理检查依赖树，exclude。pom.xml中有哪些配置
string,stringbuilder,stringbuffer
string中加号连接符是怎么执行的
string为什么是不可变性
内存模型
GC原理
set和list
hashmap底层原理，存取过程
currenthashmap底层原理，安全性
程序中为什么要使用多线程
线程是不是越多越好，一般设置多少个
电脑CPU为4…。适合设置多少个线程用过哪些创建线程方法
callable原理
你有什么想问的。
阿里一面1、自我介绍
2、全程怼项目，问的及其细，包括你为什么选择这种方案来实现，具体怎么存储怎么做的，相当细，遇到这类面试官，项目不够熟，就会翻车了。
3、redis原子操作怎么用比较好
Redis所有单个命令的执行都是原子性的。redis实现事务的原理
批量操作在发送EXEC命令前被放入队列缓存收到EXEC命令后进入事务执行，事务中任意命令执行失败，其余的命令都不会被执行在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中4、消息队列会吗？阿里二面操作系统模块：1、说一下并行和并发的区别
2、你知道进程吗？有进程为何还有线程？1进程太重了，一个程序要支持多个任务，都开进程开销太大，而且不能共享数据。3、操作系统是如何调度进程呢的
4、比如linux下我打开一个文件调用read函数，整个过程说的越用户缓冲区到内核缓冲区，read操作，阻塞等待系统调用完成，当然io操作需要磁盘寻道，内存读取数据，写入缓冲区，调用返回
5、同步异步阻塞非阻塞IO详细越好。
其他记不起来了。其实这些扩展开来就能说很多，就包含文件系统，进程管理和调度，就差内存管理机制了，我自己说了，虚地址保护模式。网络模块：TCP报文格式
TCP和UDP
拥塞控制
超时重传
三次握手
滑动窗口
常见协议的端口号
数据库模块：索引数据结构
索引优化
存储引擎
事务（spring框架如何实现事务的呢）
分库分表
Java模块：
hashmapArraylist和linkedlistvoliate
线程池,如何根据CPU的核数来设计线程大小，如果是计算机密集型的呢，如果是IO密集型的呢？1计算密集型线程执行较慢，不需要太多线程，只需要发挥多核能力即可，一般设为核心数
线程状态以及API怎么操作会发生这种转换
JVM：他说只问三个问题，1、垃圾什么时候被回收2、是怎么回收的呢
3、忘了。。。。分布式：1、redis
2、分布式事务解决，你知道我们阿里巴巴是怎么做的吗？TCC和rocketmq事务消息。3、消息队列kafka4、分库分表mycat5、CAP暂时只能记起这么多明天醒了再补，时长1小时17分钟。你打住我知道你的掌握程度了期间这句话说了很遍。我知道了，你不用说的这么详细。我们不在这个上面纠缠了，下一个。阿里三面自我介绍hashmap
红黑树
项目问的很多
就聊了20分钟
1jvm内存模型说一下
2缺页机制能说一下吗发出缺页中断，执行中断处理程序，进行页面调度。3mysql隔离机制，索引，mysql架构
4sparksql源码看过吗？
5说一下rnn梯度消失的原理，怎么解决的
6你的模型存在什么问题？（这个面试官感觉不太懂，强行问的）
7算法题链表的反转递归非递归多重背包
8你有什么问题要问我吗？
刚刚经历了人生中的第一次面试，感觉多半是要凉了，现在把问题总结一下：1.自我介绍
RFC793中规定MSL为2分钟，但这完全是从工程上来考虑，对于现在的网络，MSL=2分钟可能太长了一些。因此TCP允许不同的实现可根据具体情况使用更小的MSL值。TTL与MSL是有关系的但不是简单的相等关系，MSL要大于TTL。
b+树（答不上来），提了下红黑树，问用半分钟回答红黑树的旋转到底是怎样的？B树和B+树的关键字都比分支少一个
mysql隔离级别不会
继续提问mysql索引有哪些答不上来主键，唯一，全文，联合索引，普通索引
操作系统分页、分段是啥不会
物理分页，页面调度，分段是逻辑分段
垃圾回收机制不会
jvm内存模型。
平时开发的时候遇到哪些技术难题，怎么解决的？
项目java多线程编程
redishyperloglog原理，为什么要用它
sparkkafka的offset为什么要存在mysql理
虚拟内存概念
算法题将一个四则表达式变为后缀波兰表达式比如1+5*2变为125*+
一面：1.自我介绍一下，然后问你最擅长哪一方面(我说虚拟机、集合)
2.他说HashMap我现在都不敢问了，出过很多笑话，很多人都是背的，自己没办法判断是看的还是背的
3.简单说下HashMap的get方法实现
4.HashMap数组的第一个元素存的是什么(我不知道然后他说HashMap可以存’呐亩’吗，我听成能不能存enum，我说可以可以能存Integer，String，enum，然后他说是null，不是enum…)
5.HashMap和Hashtable的区别(线程安全不安全，能否存null，数组初始化容量，扩容不一样，elements方法hashcode方法)
6.里面的hashcode有什么区别(HashMap多了和hashcode>>>16的一次异或，这个看过和他扯了好久好久，扯到为什么2的整次幂反正扯了一大堆)
7.Hashtable在null的处理是怎样的
8.线程的几种状态(运行阻塞就绪，他说还有其他的吗，我说挂起？，他说线程生命周期什么的)
9.这些状态之间怎么转换的，哪些方法转换
10.一个线程连着调用start两次会出现什么情况(这个讨论了好久好久，他说给你设计这个start你怎么处理这种情况，直接懵逼…提示结合那个线程状态机制想下)报异常。
11.多线程这块对哪些熟悉(我吓得瑟瑟发抖，毕竟简历上写的熟悉，但自己几斤几两还是知道的，就是知道synchronized和volatile，ConcurrentHashMap，CopyOnWriteArrayList这些等等…还连忙补了一句，这些并发容器只是了解一点，没看过源码，之前打算看ConcurrentHashMap的源码但是6000行可能会看的一知半解就还没看)
12.synchronized和lock的区别
13.由于我说了一般unlock放在finally里面，他就问try后面一定要跟catch吗，我说可以不跟finally但是一定要跟catch，他说try后面不能跟catch是你在书上看的还是怎么的，我说我从没见过try后面不跟catch的，再说try就是为了捕获潜在的异常，没有catch怎么抓到抛出的异常，他说我不能try…finally吗。我说我没见过，他说那这个问你也不合适…
14.lock看过多少
15.Java里面用过哪些包(我说langutiljucmath…他说util除了用过集合还用过哪些，我说Arrays、Collections，他说有哪些方法，我说排序二分查找这些，他说Collections有用过吗，里面的排序接口用过吗，答了之后又问如果是要升序里面是写a-b还是写b-a)b-a。
16.String是可变的吗，答final数组不可变，问是final的什么数组，答char
17.Strings=”abc”和Strings=newString(“abc”)区别，然后撤常量池还扯String那个intern()方法
18.StringBuffer和StringBuilder区别
19.run方法里面有个StringBuilder线程安全吗(这也扯了好久好久，我没转过弯来，他就提示哪些会出现线程不安全的问题，我说竞态条件，什么i++读取-修改-写入，或者单例懒汉的先判断后执行，然后又回到这个run方法里面的StringBuilder，我又没想出来，他又提示方法区里面的变量存在哪，我说栈啊，递归还容易出现堆栈溢出，他又问存在栈里面的是共享的吗，我说是线程私有的，忽然恍然大悟…可能我一开始就没明白这个题什么意思，面试官真是一步一步提示你，真好…)
20.Java的引用类型你知道吗(我说数组，newXXX都是引用，他说你看过深入理解JVM那本书吗，我说看过其中的内存管理、垃圾回收、类加载这些，类文件结构这些没怎么看，他说那就这个就不问了)
21.那强引用弱引用这些知道吧(说了下强软弱虚四种引用，然后问我后三种引用的应用场景，这个之前撇过一眼，真的不记得了…回去看了下软引用可以实现缓存，弱引用可以用来在回调函数中防止内存泄露，虚引用能在这个对象被收集器回收时收到一个系统通知。)
23.大对象是哪些(我说大数组和大字符串，他说多大叫非常大，我说好像有个参数能设置大概4MB不是很清楚，然后就是年龄增长那个机制之类的)
24.MinorGC和FullGC，又扯了好久，反正基本把第二章第三章里面的内容给问了个遍还问的特别细…
25.JVM里面的参数知道哪些，默认大小是多少，我说只知道XmxXmsXss这几个，他说你猜这个中间的m是什么意思，我说是max,min可又感觉不是…他说其实他也不知道，就是看看我的想象能力，他说他猜得是memory，还有这种操作…然后问Xmn是什么，答不知道…，问你在猜猜…年轻代空间
26.G1停顿吗，CMS回收步骤
28.类加载了解吗(扯了一堆顺便说了双亲委派机制，他问为什么要每次从上往下加载？好处是什么？我说比较安全…防止重复类加载…也不知道扯得对不对)
29.数据结构掌握程度怎么样？(再次瑟瑟发抖，面试官说链表我能问吗？问怎么判断两个单链表是否相交…就这题他提示我好久，最后还是没想出来，就是这么的渣…他说直接判断最后一个节点是否相交就好，我说是不是类似一个竹子从中间砍了一点，然后前面分叉，后面相交这样，他说对对对，是这样的)
30.数据库熟悉吗(我把我知道的全说出来了，然后说除了这些都不会了，他说那我就不问了)
31.项目这些框架用到什么程度，看过源码吗
32.说说项目(因为是自学，我就直接说这个项目是跟网上的教程一步一步敲得，自学弄哪些高并发分布式的项目也不大现实。说说你写在简历上的项目亮点，我说处理了横向越权、纵向越权的情况，具体说了之后，
最后说一句，就喜欢这种问你最擅长什么，这个东西我是能问还是不能问的面试官，虽然答得一般但还是五星好评…变成面试中了…面试状态从简历评估中变成了待安排面试什么鬼？难不成这面只是简历面吗？简历面：面试官上来介绍了他们部门的业务，问我感不感兴趣，我当然感兴趣了，然后开始疯狂输出我…1.起手式：Object类有哪些方法？
wait方法能不能被重写，wait能不能被中断
里面哪些方法能被重写
hashcode方法有什么用
HashSet方法里面的hashcode存在哪(我说类似HashMap存在Node里面，他还是问了我好久，没看过源码很虚)Node里的hash值
一个对象的id为1，通过setId(2)改为2，HashSet里面有几个对象，这问了好久好久，没明白他什么意思一个对象
线程有几种状态，创建线程的几种方法
哪些方法能使线程从运行态变为阻塞态
说说线程池，线程池中一个线程执行完任务后处于那种状态
Thread类的interrupt,interrupted,isInterrupted方法的区别interrupt改变中断标识位，interrupted改变并返回标识位，isInterrupted只返回标识位
一般通过轮询标识位，标识位改变时throwinterruptexception，然后我们通过catchinterruptexception的方法来执行中断。
自己写的两个不同的类是被同一个类加载器加载的吗？为什么？是的。都是appclassloader
CPU能不能直接和二级缓存打交道，接下来一顿问…
可以的，主不过80%走一级缓存，20%走二级缓存二级缓存是CPU性能表现的关键之一，在CPU核心不变化的情况下，增加二级缓存容量能使性能大幅度提高。而同一核心的CPU高低端之分往往也是在二级缓存上存在差异，由此可见二级缓存对CPU的重要性。CPU在缓存中找到有用的数据被称为命中，当缓存中没有CPU所需的数据时（这时称为未命中），CPU才访问内存。从理论上讲，在一颗拥有二级缓存的CPU中，读取一级缓存的命中率为80%。也就是说CPU一级缓存中找到的有用数据占数据总量的80%，剩下的20%从二级缓存中读取。由于不能准确预测将要执行的数据，读取二级缓存的命中率也在80%左右（从二级缓存读到有用的数据占总数据的16%）。那么还有的数据就不得不从内存调用，但这已经是一个相当小的比例了。目前的较高端CPU中，还会带有三级缓存，它是为读取二级缓存后未命中的数据设计的—种缓存，在拥有三级缓存的CPU中，只有约5%的数据需要从内存中调用，这进一步提高了CPU的效率，从某种意义上说，预取效率的提高，大大降低了生产成本却提供了非常接近理想状态的性能。除非某天生产技术变得非常强，否则内存仍会存在，缓存的性能递增特性也仍会保留。
网络编程会吗
socket中accept什么用阻塞等待请求到来
两个不同ip地址的计算机之间如何通信如果在一个局域网，那么直接通过2层通信，如果不在一个局域网，那么通过路由器路由再进行2层通信
项目中用过Spring吗
Spring优点哪些，源码看过吗
SpringMVC怎么配置的，xml文件怎么加载的(问了下是要说源码)，一次HTTP请求的过程(其实不是问这个的，它问的什么我没听懂，我说是不是SpringMVC的请求执行过程，他说不是)
数据库连接池用过吗，来说一说一般用一个容器保存多个连接，可以复用，类似线程池。
项目中的MySQL、Nginx这些都是自己配置的吗一部分是
有什么想问我的？
总共47分钟，被问懵逼了，但不得不说面试官的态度一直很好，不会的问题会不断给你提示（然而学渣给再多的提示也答不出来，这TM就很尴尬了），哎越面越感觉自己越菜，只能为阿里秋招攒波人品了…
先问了在内存中查询数据和在数据库中查询数据的区别
然后问了数据事务ACID以及数据库隔离级别，脏读，不可重复读，幻读的解决方案
接下来问了类加载机制（Bootstrap，双亲委派，运行时常量池），JVM内存分配（堆栈，垃圾回收）
设计模式（单例，观察者，装饰者，代理，工厂）
然后虚拟内存（不会），网络四层结构（不会）
问了spring的MVC（我只会这个），接下来可能问IOC，AOP，事务的注入，Spring一致性原理，注解什么的，我都没仔细看，你可以看看
自我介绍，技术栈介绍
2.那前端怎么异步呢？（我说可以轮讯，或者用socket.io建起长连接通信）
3.ArrayList底层，扩容
4.很多很多个数，找到前十个（分治，堆排序）
6.CountDownLatch(我居然忘记这玩意叫啥了，我就说java有这么一个东西，可以解决这个问题，或者也可以用信号量机制来)
7.HTTP和TCP
8.TCP关闭连接四次挥手，为啥
9.ArrayQueue和LinkedQueue（这里没答好，他问“ArrayQueue相比LinkedQueue”有啥好处，真不知道该答什么，难度是占用空间小？最后直接说了不知道o(╥﹏╥)o）
持续18分24秒感觉凉了
1面
先从基础开始
1平时用过哪些集合？（重点说了下Hashmap）
2刚说到Hashmap非线程安全，为什么？（扩容会有环）
3（前面有主动提到HashTable和ConcurrentHashmap）这两者有什么区别？分段锁的具体细节？
4（回答Hashmap的时候有提到j8里面用红黑树优化）红黑树原理？
5（ConcurrentHashmap有提到j8乐观锁优化）乐观锁原理？（结合项目场景）
6NIO用过吗？说下和BIO的区别？
7聊一下印象最深刻的项目？（吧啦吧啦一堆）
8后面的问题基本围绕项目（有问到nginx和redis，多级缓存）
2面
1说下印象最深刻的项目（吧啦吧啦一堆，大概围绕项目问了4到6个问题，其中负载均衡和缓存重点）
2CI了解吗？中文怎么说？假如开发过程中代码集成后发现出错了怎么处理？持续基础
3（简历）说下Java的类加载机制？
4哪些情况下会触发类加载？
jvm初始化。自定义类加载器就行加载，加载外部类
5JVM模块？堆的分代？
6说下Java里面的锁？
7问了下设计模式（具体哪种不太记得）
8线程池？简单写个连接池？
9出了两个简单的题（一个动态规划的，一个环状链表，说了下思路）
3面（这面印象比较深，问的稍微深一点）开场（前面同事问基础和项目问的比较多，我就问点技术上的）1Spring事务了解吗？说下你知道的
3事务的隔离级别？传播级别？在什么场景下用？
4AOP用过吗？大致说下
5AspectJ和Spring的AOP有哪些区别？
联系我们借助于SpringAop的命名空间可以将纯POJO转换为切面，实际上这些POJO只是提供了满足切点的条件时所需要调用的方法，但是，这种技术需要XML进行配置，不能支持注解所以spring借鉴了AspectJ的切面，以提供注解驱动的AOP，本质上它依然是Spring基于代理的AOP，只是编程模型与AspectJ完全一致，这种风格的好处就是不需要使用XML进行配置
6SpringMVC处理请求的流程？
找到处理器，然后执行方法，渲染页面，返回响应
7用过RPC框架吗？说说你对RPC的理解
8你刚有提到ApachThrift，说下服务端和客户端基本编码步骤？
9说下Thrift的IO模型？
10mybatis的延迟加载知道吗？怎么写？批处理怎么写？动态sql？（顺序可能有点乱，记得不是很清楚）
11mybatis的占位符？怎么防止sql注入？（算常识了）#
13你简历上说用过Kafka和Rabbit，区别在哪？什么场景？
14Kafka的是写入效率？写到磁盘，为什么能到O（1）？怎么提高消费端的并发？
零拷贝，并发分发消息，使用推模型
15有什么想问我的吗。。。（每次面完都有这句，懒得写了）
4面
总结：
阿里的几轮面试感觉比较重基础和实现的的一些原理，面试官应该有通过气。
1面是比较重基础，集合基本上是必问了，特别是Hashmap这块的，尽量多了解点，把底层实现搞清楚了里面的东西你甚至能和面试官扯半小时
2面基本上是项目为主，有问到一些JVM的东西，还会问些实操，结合简历。
3面问技术，简历上写的框架了解的越全越好，有的面试官可能会往深度问，比如问底层原理底层实现，有的面试官可能问的比较全一点。
自我介绍在学校里和实习公司里做项目用的什么技术Java基础3.Java读取一个文件,有哪些方法,考虑性能,用哪一个类
BIO,NIO,AIO区别
NIO的组件,Selector(这个忘记了,一脸懵逼!)
什么是序列化,IO的序列化方式,为什么需要序列化(包括在网络传输的情况下)
Error和Exception区别
RuntimeException和非RuntimeException区别
什么叫线程安全,保证线程安全的方法
加锁的方式,synchronized作用在方法上和代码块区别
synchronized(this)和synchronized(Xx.class)区别
Web方面:12.SpringAOP实现原理
一个页面,一个提交按钮,如何防止重复提交,我说验证码,还有其它方式吗token
ajax实现跨域请求(前端或者后台实现方法)
cookie和session区别
forward和redirect区别后者是重定向，地址不变。前者是跳转，地址会跟着变。
数据库(这个全程被怼,看来这个要好好复习了):这里还有几个问题,没听清楚,所以就没写了!17.你建过索引吗建索引的原则
索引的类型,如主键索引
查看SQL执行计划
有十万条数据,写SQL语句查询其中某字段较大值的几条数据
子查询与关联查询的区别
JVM22.你用过的JVM命令有哪些jps，jstack，jmap，jstat23.如果一个程序发生OOM,该怎么处理排查内存dump。看堆中有什么大对象持续存活，看看方法区，也检查下gc日志。24.Java类加载机制
为什么使用双亲委派模型
JVM内存模型
JDK7与JDK8的JVM内存模型区别永久代变成元数据区网络:
HTTP1.0与HTTP1.1区别TCP与UDP区别最后30.你有哪些问题要问我的
问的都比较基础,有好多问题,我之前都复习过了,没想到这么快就忘记了,归根到底是没有深入理解其本质;
事后发现自己回答地太快了,有些东西没有说清楚,估计是有点紧张啊;
当时上海这边风真大,有几个问题,问了两遍,硬是没有听清楚,最后尴尬而不失礼貌地说了句”不知道”.
接下来,好好复习,继续总结,加油!
还热乎的阿里题
阿里：1.逻辑题；100的阶乘有几个0
有几个5就有几个0。5-95一共有10个5，而55有两个5，所以有11个0.
2.listsetmap底层使用什么实现的有哪些典型实现
3.hashmap五个线程~同时put值会发生什么后果
可能会形成死链
4.hashmap扩容是怎么扩容的，为什么是2的幂2倍扩容，2的幂，所以哈希值&(2的幂-1）就是去哈希值后几位
5.concurrenthashmap为什么线程安全，采用了什么措施应对高并发
7.定长队列5，最高线程6个，核心3个，100个任务同时请求，怎么处理的
执行拒绝策略
8.情景题:按钮点一下后台生成订单，当用户疯狂点的时候怎么正常生成订单
两者在原理上都是通过sessiontoken来实现的。当客户端请求页面时，服务器会生成一个随机数Token，并且将Token放置到session当中，然后将Token发给客户端（一般通过构造hidden表单）。下次客户端提交请求时，Token会随着表单一起提交到服务器端。
2、应用于“防止表单重复提交”：服务器端第一次验证相同过后，会将session中的Token值更新下，若用户重复提交，第二次的验证判断将失败，因为用户提交的表单中的Token没变，但服务器端session中Token已经改变了。
9.分布式框架了解吗，nginx了解吗。dubbo了解吗，docker了解吗，数据库了解吗。。（自己简历写的坑）自己作死Nginx负载均衡反向代理dubbo是rpc框架docker容器
Docker并不是LXC的替代品，Docker的底层就是使用了LXC来实现的。LXC将Linux进程沙盒化，使得进程之间相互隔离，并且能够控制各进程的资源分配。在LXC的基础之上，Docker提供了一系列更强的功能。
问题：1.项目balabala（20分钟）
2.redisrdb和aof（redis必问环节）
3.redis事务
4.hashmap底层
5.threadpoolexecutor关键参数解释
6.blockqueue实现消费者和生产者通过put和take方法，介绍put和take底层实现lock锁，数组队列使用一个锁，链表队列使用两个锁。读写锁使用一个队列7.场景设计：多个线程结束后再运行主线程
8.原子包的实现
9.fail-fast原理检查modcount，不符合的话抛出conmodifyexception10.lock和synchronized，涉及可重入锁，锁的优化（偏向锁，轻量级锁，自旋锁的实现细节）偏向锁使用偏向线程号标识。轻量级锁把锁记录复制到对象头，然后替换锁记录为指向对象头的指针，替换成功则加锁成功。自旋锁就是循环请求不加锁，但是会占用cpu
11.设计一个缓存系统（基于LRU的过期策略）（15分钟）链表。访问时放到链表头，否则先进先出。超过容量时删除尾节点。我们使用的是头插法。反之应该也可以。
最后一个题真虐！！！
还有一些我忘了问的啥，这次是真的紧张
1.幻读以及MVCC确实是使用mvcc解决的幻读
2.1000个列，列的值非0即1，求每一行值大于300的数据行，全部select出来
3.进程中断interrupt
5.动态规划原理以及和分治法区别
6.二叉树深度求解
7.springMVC，springAOP源码
8.spring循环引用检测
9.spring事务传播机制required说明需要开启事务。never表示不开启事务support表示可以开可以不开
10.可重用锁
11.doublecheck介绍
12.javanio，bio，aio，操作系统底层nio实现原理
13.一个任务分成多个任务，最后汇总计算，不能用fork/joinMapReduce，线程池future接收结果
14.感兴趣的方向
一面，全程一个小时左右：一上来先说自己实习做的项目，然后面试官开始问项目细节，然后又开始说学校里做的项目，这两个加起来就快四十分钟了，因为每个人项目不一样就不介绍跟项目关系太大的，说几个通用型问题
1：为什么你的缓存更新策略是先更新数据库后删除缓存，讲讲其他的情况有什么问题先更新缓存再更新数据库
2：两个线程打印1.2.3.4打印到100怎么实现，这里刚开始说的是加锁用生产者消费者来做，后来说了semaphore，感觉后面的才是面试官想要的答案。
3：spring的aop的实现方式，aspectj和jdk动态代理，cglib动态代理，讲了下实现的原理
4：hashmap实现原理，把知道的都说出来。
二面，在周二，也是一个多小时，一来还是说的实习项目，然后直接问问题1.缓存的使用策略和从底层数据库开始往上各个层级中缓存的使用，把你知道的都说出来，这个问题刚开始有点懵逼，后来就从数据库底层原理开始说起，然后讲了缓存的各种使用策略，和这些策略避免的什么问题，这里讲了好久，边说边被追问，里面涉及到各种缓存击穿，缓存穿透，缓存雪崩，互斥锁等内容
穿透就是不走缓存
雪崩就是大量缓存同时失效
2.假如双十一等一些促销有高并发访问量要来访问我们的数据，怎么样做到可靠的服务，这个问题我说了很多处理高并发的东西，但是好像不是最终答案，好像是问题没听太明白，不过不影响接下来是项目，也是深挖了好多东西，怼了半天，通用的问题还有：
2.springboot和spring的区别配置方便，内置tomcat3.你是怎么保证你的代码质量和正确性的代码规范，设计模式，以及单元测试
三面：没有任何基础知识，上来直接问项目，项目问了很多，然后从项目引申到具体的业务场景：1消息队列的生产者消费者中消费者没有收到消息怎么办，消息有顺序比如1.2.3但是收到的却是1.3.2怎么办？消息发过来的过程中损坏或者出错怎么办
类似tcp滑动窗口的有序传输，超时重传2下单过程中是下订单减库存还是付款减库存，分析一下两者的优劣下单减库存，防止大量失效订单。
支付减库存，防止恶意下订单3高并发场景的限流，你怎么来确定限流限多少，模拟场景和实际场景有区别怎么解决，动态改变限流阀值遇到的问题1根据系统的瓶颈估算。2压测3调整限流阈值，应该逐步调整。
总的来说三场面试都没什么我那看了那么久的基础知识的用武之地，主要还是看你怎么能够把知识和实际情况能够结合起来，毕竟校招，考察的还是一个人的学习能力和一种思维话说最近真的是很纠结，选择比努力重要，衷心希望大家都能找到满意的工作
2.紧接着就问什么是树，二叉树有什么优点，这个我就瞎扯了一通。
3.然后问我知道哈希吗？问二叉树比哈希牛逼在哪里？各自有什么优缺点，我就从查找和排序上个举了个例子。
4又接着问了点排序的，问哈希解决冲突有哪些机制。
5.websocketWebSocket规范的目标是在浏览器中实现和服务器端双向通信。浏览器和服务器只需要要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。在此WebSocket协议中，为我们实现即时服务带来了两大好处：互相沟通的Header是很小的-大概只要2Bytes、服务器可以主动传送数据给客户端。目前还只有部分浏览器支持此协议。7.又问了设计模式，问我了模板方法设计模式。
最后是两个开放题目8.你觉得自己有哪些有点。
9问我对分布式操作和软件有什么了解，我为了避免尴尬，把自己实习经历又扯了一通。
总之，一面问的很广，想到什么问什么。另外就是还是需要很扎实的基本功。至少要对自己的岗位基础知识很了解。还有就是随时做好准备，很容易突击，否则就会像我一样一脸懵逼。反正我感觉我凉凉了，祝各位好运！
阿里巴巴(业务平台技术质量部测试开发)：
一面(2018/7/16晚上十点一个小时左右):1:自我介绍
2:HashMap怎么解决Hash冲突的
3:ConcurrentHashMap怎么解决线程安全
4:常见的排序有没有了解过
5:一堆基本有序的数组，用哪种排序效率最高
12:哪些东西放在栈区
13:双亲委派模型,有什么好处
14:wait和sleep有什么区别
15:线程池几个参数
16:怎么评估线程数大小
17:几个线程访问同一个东西，怎么保证安全
18:Spring几个特点说下
19:CGLib有没有了解过
20:Spring支持哪几种切片1234567891011121314151617aop和aspect
21:SpringBoot和Spring有什么区别
22:SpringBoot和Spring启动有什么区别
23:Spring启动生命周期
24:Spring注解@Resource和@Autowired区别对比=>优先级不一样1234567@Autowire默认按照类型装配，默认情况下它要求依赖对象必须存在如果允许为null，可以设置它required属性为false，如果我们想使用按照名称装配，可以结合@Qualifier注解一起使用;
@Resource默认按照名称装配，当找不到与名称匹配的bean才会按照类型装配，可以通过name属性指定，如果没有指定name属性，当注解标注在字段上，即默认取字段的名称作为bean名称寻找依赖对象，当注解标注在属性的setter方法上，即默认取属性名作为bean名称寻找依赖对象.25:spring@service@controller@componet三者区别
26:Http和Https协议有什么区别，证书了解不
27:介绍下Redis设计实现
28:Redis的细节源码看过没有12345数据结构
29:Redis分布式缓存1codisrediscluster
30:线程在频繁的FullGC怎么排查
31:JVM一些工具，jps,jmap
32:你有啥问题12345二面(2018/7/19晚上九点40分钟左右):1:自我介绍2:实习做什么3:你对哪个语言最熟悉4:Java的内存模型5:垃圾回收的原理6:你写过Java的Web系统7:简单介绍一下你的项目
一面把我的老底都翻光了，校招真不是跟实习一个级别的。
有没有老哥做测试开发或者了解测试开发的，值不值得去，一直是后台方向的怕全是测试，大方向错了，就GG了
2、微服务架构是什么，它的优缺点？soa体系下更细粒度的拆分，基础是rpc，扩展是服务治理，加强版是容器，计算，资源调度，监控，限流等。3、ACIDCAPBASE理论
4、分布式一致性协议，二段、三段、TCC，优缺点二段死锁三段解决二段问题tcc尝试提交失败补偿。
5、RPC过程动态代理
6、服务注册中心宕机了怎么办？zk是集群部署的，可以自动进行选主我们都知道，Zookeeper要安装在奇数个节点，但是为什么？Zookeeper的大部分操作都是通过选举产生的。比如，标记一个写是否成功是要在超过一半节点发送写请求成功时才认为有效。同样，Zookeeper选择领导者节点也是在超过一半节点同意时才有效。最后，Zookeeper是否正常是要根据是否超过一半的节点正常才算正常。这是基于CAP的一致性原理。
zookeeper有这样一个特性：集群中只要有过半的机器是正常工作的，那么整个集群对外就是可用的。也就是说如果有2个zookeeper，那么只要有1个死了zookeeper就不能用了，因为1没有过半，所以2个zookeeper的死亡容忍度为0；同理，要是有3个zookeeper，一个死了，还剩下2个正常的，过半了，所以3个zookeeper的容忍度为1；同理你多列举几个：2->0;3->1;4->1;5->2;6->2会发现一个规律，2n和2n-1的容忍度是一样的，都是n-1，所以为了更加高效，何必增加那一个不必要的zookeeper呢。7、微服务还有其他什么组件监控，服务熔断，服务降级，消息总线等。8、分布式架构与微服务的关系更加细粒度，更加注重独立部署，快速迭代，以及独立性。9、你有什么问题要问我的。
2、二叉树的深度
操作系统来两道
3、虚拟内存分页了解不？
4、进程和线程区别
数据库来三道
5、第一二三范式是什么？
6、一个表一千个列值为true和false，写sql查询有300个列值为true的行。不会7、脏读和幻读是什么？
JVM
7、什么对象会从新生代晋升到老年代
多线程8、一个任务分成十个任务，最后汇总计算，不能用fork/join
9、实习+项目问题，基本是在联想研究院做的东西，还问我为什么不留那。。。