五轮阿里面试题及答案

一面

自我介绍下自己，不超过3分钟（实际上我的自我介绍不到一分钟）
你感觉比本科阶段自己进步了多少，有哪些进步
研究生期间最大的进步是什么
你觉得你适合从事哪个方向的开发
synchronized与lock的区别，使用场景。看过synchronized的源码没
JVM自动内存管理，Minor GC与Full GC的触发机制
了解过JVM调优没，基本思路是什么

如果CPU使用率较高，GC频繁且GC时间长，可能就需要JVM调优了。
基本思路就是让每一次GC都回收尽可能多的对象，
对于CMS来说，要合理设置年轻代和年老代的大小。该如何确定它们的大小呢？这是一个迭代的过程，可以先采用JVM的默认值，然后通过压测分析GC日志。

如果看年轻代的内存使用率处在高位，导致频繁的Minor GC，而频繁GC的效率又不高，说明对象没那么快能被回收，这时年轻代可以适当调大一点。

如果看年老代的内存使用率处在高位，导致频繁的Full GC，这样分两种情况：如果每次Full GC后年老代的内存占用率没有下来，可以怀疑是内存泄漏；如果Full GC后年老代的内存占用率下来了，说明不是内存泄漏，要考虑调大年老代。

对于G1收集器来说，可以适当调大Java堆，因为G1收集器采用了局部区域收集策略，单次垃圾收集的时间可控，可以管理较大的Java堆。

如何设计存储海量数据的存储系统

海量数据的解决方案：
页面上：
使用缓存；页面静态化技术；
数据库层面：
分离数据库中活跃的数据；批量读取和延迟修改；读写分离；使用NoSQL和Hadoop等技术；分布式部署数据库；应用服务和数据服务分离；
其他方面：
使用搜索引擎搜索数据库中的数据；进行业务的拆分；
高并发情况下的解决方案：
应用程序和静态资源文件进行分离，静态资源可以使用CDN；
集群与分布式；
使用Nginx反向代理；

缓存的实现原理，设计缓存要注意什么
将热点数据放在内存中，用户查询时命中内存中的数据而不用到数据库中查询
注意缓存的一致性，缓存雪崩、击穿、穿透的问题

淘宝热门商品信息在JVM哪个内存区域
？？，不应该在缓存中嘛，然后落地在数据库里，跟JVM有屁关系
操作系统的页式存储
把内存分成大小相同的内存页，然后程序通过页表来查询到自己的存储位置，这样就可以使用不连续的内存来加载程序
事实上现在都用虚拟内存的方式，把程序分段加载到虚拟内存中，再把内存分页，通过段表、页表的形式来映射程序在内存中的位置
volatile关键字的如何保证内存可见性
volatile修饰的变量保证其每个写操作后都更新到主内存，每个读操作都到主内存中更新，具体的话是在JVM层面，在修饰的变量前后加关键字
顺带一提volatile还能防止指令重排，这两者的实现方式都是内存屏障。

happen-before原则
如果前一个操作的执行结果必须对后一个操作可见，那就不允许这两个操作进行重排序，且happen-befor具有传递性
Lucene全文搜索的原理
先将全文由分词器进行分词，会提取出关键词和频率，然后这个关键词后面也会跟着一个链表，这个链表记录了有个关键词的文档。我们通过关键词搜索就可以找到这串链表，也就得到了所要的文档了。
你觉得自己适合哪方面的开发，为什么
JavaWeb的后端开发，一个当然是对这方面感兴趣，涉及范围广，然后目前掌握的比较多的也是这方面的内容，技能比较熟练，自己认识的圈子也是这个圈子里的人，如果遇到问题也容易解决，自己也有一套这方面的学习方法，如果去学习其他的话，倒不是走出舒适区的问题，而是对于现阶段的我来说，不能做到在短时间内取得阶段性的成果
想去哪里实习，杭州？

二面

自我介绍下自己，不超过3分钟（我的自我介绍仍然不超过1分钟）
你说你熟悉并发编程，那么你说说Java锁有哪些种类，以及区别（果然深度不一样）
公平锁/非公平锁
这个是在ReentrankLock中实现的，synchronized没有，是用一个队列实现的，在公平锁好理解，就是先进这个队列的，也先出队列获得资源，而非公平锁的话，则是还没有进队列之前可以与队列中的线程竞争尝试获得锁，如果获取失败，则进队列，此时也是要乖乖等前面出队才行
可重入锁
如果一个线程获得过该锁，可以再次获得，主要是用途就是在递归方面，还有就是防止死锁，比如在一个同步方法块中调用了另一个相同锁对象的同步方法块
独享锁/共享锁
共享锁可以由多个线程获取使用，而独享锁只能由一个线程获取。
对ReentrantReadWriteLock其读锁是共享锁，其写锁是独占锁
读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的。其中获得写锁的线程还能同时获得读锁，然后通过释放写锁来降级。读锁则不能升级
互斥锁/读写锁
上面讲的独享锁/共享锁就是一种广义的说法，互斥锁/读写锁就是具体的实现。
互斥锁在Java中的具体实现就是ReentrantLock
读写锁在Java中的具体实现就是ReadWriteLock
乐观锁/悲观锁
乐观锁就是乐观的认为不会发生冲突，用cas和版本号实现
悲观锁就是认为一定会发生冲突，对操作上锁
分段锁
在1.7的concurrenthashmap中有分段锁的实现，具体为默认16个的segement数组，其中segement继承自reentranklock，每个线程过来获取一个锁，然后操作这个锁下连着的map。
偏向锁/轻量级锁/重量级锁
在jdk1.6中做了第synchronized的优化，
偏向锁指的是当前只有这个线程获得，没有发生争抢，此时将方法头的markword设置成0，然后每次过来都cas一下就好，不用重复的获取锁
轻量级锁：在偏向锁的基础上，有线程来争抢，此时膨胀为轻量级锁，多个线程获取锁时用cas自旋获取，而不是阻塞状态
重量级锁：轻量级锁自旋一定次数后，膨胀为重量级锁，其他线程阻塞，当获取锁线程释放锁后唤醒其他线程。（线程阻塞和唤醒比上下文切换的时间影响大的多，涉及到用户态和内核态的切换）
自旋锁：在没有获取锁的时候，不挂起而是不断轮询锁的状态

如何保证内存可见性
volatile 通过内存屏障
synchronized 通过修饰的程序段同一时间只能由同一线程运行，释放锁前会刷新到主内存

Http请求的过程与原理
三次握手与四次挥手？
通过HTTP网络请求过程中的TCP协议
TCP连接的特点
相较于UDP来说，更加安全可靠,是面向连接，传输的话是以流的形式传输
TCP连接如何保证安全可靠的
为什么TCP连接需要三次握手，两次不可以吗，为什么
不可以两次握手只能一方确认自己的收发没有问题，而另一方的收没问题，发可能存在问题
AOP的原理
静态织入，动态代理
JDK动态代理与cglib实现的区别（这个，醉得很厉害）
接口（反射）/继承
那么你说说代理的实现原理呗
1.创建一个接口
2.创建一个实现了这个接口的实现类
3.创建一个实现了这个接口的代理类，在代理类中实例化实现类，并且调用实现类中的方法
看过Spring源码没，说说Ioc容器的加载过程吧
简单概括：
1.刷新预处理
2.将配置信息解析，注册到BeanFactory
3.设置bean的类加载器
4.如果有第三方想再bean加载注册完成后，初始化前做点什么(例如修改属性的值，修改bean的scope为单例或者多例。)，提供了相应的模板方法，后面还调用了这个方法的实现，并且把这些个实现类注册到对应的容器中
5.初始化当前的事件广播器
6.初始化所有的bean
7.广播applicationcontext初始化完成。

 

//来自于AbstractApplicationContext
public void refresh() throws BeansException, IllegalStateException {
       //进行加锁处理
   synchronized (this.startupShutdownMonitor) {
       // 进行刷新容器的准备工作，比如设定容器开启时间，标记容器已启动状态等等
       prepareRefresh();

       // 让子类来刷新创建容器
       // 这步比较关键，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，
       // 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，
       // 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 map)
       ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

       // 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
       prepareBeanFactory(beanFactory);

       try {
           // 这里需要知道 BeanFactoryPostProcessor 这个知识点，
           //Bean 如果实现了此接口，那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。
           // 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
           // 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
           postProcessBeanFactory(beanFactory);

           // 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法
           invokeBeanFactoryPostProcessors(beanFactory);

           // 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
           // 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
           // 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
           registerBeanPostProcessors(beanFactory);

           // 初始化当前 ApplicationContext 的 MessageSource
           initMessageSource();

           // 初始化当前 ApplicationContext 的事件广播器
           initApplicationEventMulticaster();

           // 从方法名就可以知道，典型的模板方法(钩子方法)，
           // 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
           onRefresh();

           // 注册事件监听器，监听器需要实现 ApplicationListener 接口
           registerListeners();

           // 初始化所有的 singleton beans（lazy-init 的除外）
           // 重点方法将会在下一个章节进行说明
           finishBeanFactoryInitialization(beanFactory);

           // 最后，广播事件，ApplicationContext 初始化完成
           finishRefresh();
           }
           catch (BeansException ex) {
               if (logger.isWarnEnabled()) {
                   logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + ex);
               }
                   // 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源
                   destroyBeans();

                   // Reset 'active' flag.
                   cancelRefresh(ex);

                   // 把异常往外抛
                   throw ex;
             }
             finally {
               // Reset common introspection caches in Spring's core, since we
               // might not ever need metadata for singleton beans anymore...
               resetCommonCaches();
             }
     }
}

了解过字节码的编译过程吗（这个还真不知道）

 

 

三面

自我介绍，不超过3分钟（这次好像时间更久了，也就2分钟多点）
说一下你对哪个项目比较熟悉
数据库项目
为什么做这个项目
当时公司里为了整改balabala
项目采用了什么架构，数据库如何设计的
简单是MVC架构，数据库
数据库由哪些表，为什么有这些表

主要有哪些核心模块，模块之间如何通信的
session放在哪里

如何保存会话状态，有哪些方式、区别如何
cookie 保存在客户端，容易篡改
session 保存在服务端，连接较大的话会给服务端带来压力，分布式的情况下可以放在数据库中，
优点：
1：简单且高性能
2：支持分布式与集群
3：支持服务器断电和重启
4：支持 tomcat、jetty 等运行容器重启
缺点：
1、需要检查和维护session过期，手动维护cookie；
2、不能有频繁的session数据存取；

token 多终端或者app的话一定要这个，
随着技术的发展，分布式web应用的普及，通过session管理用户登录状态成本越来越高，因此慢慢发展成为token的方式做登录身份校验，然后通过token去取redis中的缓存的用户信息，随着之后jwt的出现，校验方式更加简单便捷化，无需通过redis缓存，而是直接根据token取出保存的用户信息，以及对token可用性校验，单点登录更为简单。

JWT的token包含三部分数据：

1. Header：头部，通常头部有两部分信息：
   • 声明类型，这里是JWT
   • 加密算法，自定义
     我们会对头部进行base64加密（可解密），得到第一部分数据
2. Payload：载荷，就是有效数据，一般包含下面信息：
   • 用户身份信息（注意，这里因为采用base64加密，可解密，因此不要存放敏感信>息）
   • 注册声明：如token的签发时间，过期时间，签发人等
     这部分也会采用base64加密，得到第二部分数据
3. Signature：签名，是整个数据的认证信息。一般根据前两步的数据， 再加上服务的>的密钥（secret）
   （不要泄漏，最好周期性更换），通过加密算法生成。用于验证整个数据完整和可靠性（不要泄漏，最好周期性更换），
   通过加密算法生成。用于验证整个数据完整和可靠性

分布式session如何管理，你有哪些方案
Redis做缓存持久化存储session
数据库存储session

学过数据结构和算法吗（当然），你说说二分搜索的过程
二分搜索有一点要求就是数据有已经排序好的，假设是自然排序的，拿到目标数据后查找中间的值，如果大了，就去右边一部分的中间值比较，小了就去左边一部分的中间值

说一下快排的过程，写一下伪代码
取一个值，然后设置两个指针，一个指针先从后到前开始遍历，遇到小于这个值的就停止，然后另一个指针从前到后遍历，遇到大于这个值的就停止，知道这两个指针相遇，此时交换这个值与相遇的时候指针的值，以这个坐标为边界两边开始递归

了解哪设计模式，举例说说在jdk源码哪些用到了你说的设计模式
单例：ioc容器
模板：ioc、springmvc
建造者模式：lombok
工厂：ioc
代理：aop
订阅/发布：消息队列，redis的pub/sub

你有什么问我吗（仍然上面三个问题）

四面：

来个自我介绍呗，不超过3分钟
介绍下你最熟悉的项目
项目使用了什么架构，亮点是什么
MVC，用到Lucene，用aop实现了权限的管理
平时主要学习什么课程
Java、数据结构、数学建模
你目前的研究方向是什么
家是哪的
喜欢看什么书

大概什么时候能来实习呢
四面总结

五面

自我介绍下吧
做了哪些项目
看你在问题中说你在杭州看到很多商贩使用付款二维码，你对支付宝怎么看
每天有那么多人使用支付宝，这些数据如果给你存储，你会怎么设计呢（不是说HR不问技术问题吗？不愧是阿里的HR）
为什么想来支付宝实习呢
技术栈、对移动支付比较好奇，
你身边同学如何评价你、老师呢
如果与同事发生了意见的不一致，你会如何解决呢
首先就是要确保双方都理解了对方的意思，因为有些是沟通不充分导致的，然后同时综合对比不同意见，可能会对工作内容产生的影响，并且会根据利弊来选择方法

作者：就这些吗
链接：https://www.jianshu.com/p/c8a271448dcd
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。