面试刷题10-3

Java 面试重点内容

其实最大的感受是，Java并发编程太重要了，几乎每场面试，无论大小公司，都会问到多线程、线程池、synchronized、各种锁等等这些东西；问的第二多的是HashMap、ConcurrentHashMap、TreeMap、ArrayList等这些集合框架；然后就是JVM了，内存结构、垃圾回收算法、垃圾收集器、如何调优等等。感觉在Java方面如果把《深入理解Java虚拟机》、《Java并发编程实践》这两本书吃透，其他后台框架就算不会都能拿个不错的offer了。

 

 

总共两面，起的太早了 好多问题忘了 想起来再补充

 

一面技术

hashmap，concurrentHashmap，hashtable各介绍一下

红黑树介绍一下，跟平衡二叉树比较一下，红黑树有哪些应用场景

TreeMap底层是红黑树，红黑树效率高于平衡二叉树

zookeeper了解吗

ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。

StringBuffer和StringBuilder

前者线程完全，后者线程不完全，都是可变字符串

接口和抽象类区别

1. 抽象类只能继承一次，但是可以实现多个接口
2. 接口和抽象类必须实现其中所有的方法，抽象类中如果有未实现的抽象方法，那么子类也需要定义为抽象类。抽象类中可以有非抽象的方法
3. 接口中的变量必须用 public static final 修饰，并且需要给出初始值。所以实现类不能重新定义，也不能改变其值。
4. 接口中的方法默认是 public abstract，也只能是这个类型。不能是 static，接口中的方法也不允许子类覆写，抽象类中允许有static 的方法

面对对象的几大特性

封装，继承，多态

反射机制介绍一下

类加载机制，过程

线程的集中状态

volatile介绍一下

保证内存可见性，防止指令重排，不保证原子性

java内存模型

双亲委派模型

类加载器类别

bio，nio，aio分别介绍一下，nio的实现方式

数据库隔离级别以及分别解决了什么问题

redis数据类型，redis的应用场景，为什么redis快，

线程实现方式

死锁条件，怎么预防

锁有哪些

序列化相关

sql查询过程

 

 

直接上面经。

1. 没有自我介绍。面试官直接开始，看了我是本科的，还以为我是二面的。（这是凉的开始）。

2. 实习项目我负责的模块介绍了一下。

3. 项目的难点在那？

4. Https 和 http 的区别？

5. https 验证证书的过程讲一下。

6. 插曲：七牛云的手撕代码要共享屏幕还得翻个 qiang 下个插件。

一道手撕算法题。" abc blue skylight " --> "skylight blue abc" 空间复杂度为 O(1)

双指针，写代码的感觉

7. 你有什么想问我的吗？

1.spring aop，ioc

控制反转和依赖注入（IOC）

AOP 面向切面编程

I
2.threadlocal的底层实现
3.hashmap的底层实现
4.线程池的参数
5.类的卸载
6.求一颗树的节点数

遍历一遍
7.求一个数组里面，两个数的最大差值

求两个数组的最大值最小值
8.转帐时如何保证操作的完整性(不用事务来实现)
9.类的加载器
10.计算机网络
11.https
12.排序的时间空间复杂度

 

• 一面组长面

1.先做个简单的自我介绍吧？

自我介绍常规一点就好，别花里胡哨，主要是给面试官看简历和资料

2.看你项目中用了TCP,UDP，讲一讲他们的区别把

送分题

3.看你学过计算机网络，说说HTTP？

超文本传输协议

4.长连接有什么缺点？

5.一次性传10张图片需要几次连接？

6.操作系统也学过？那说说进程和线程吧

7.协程知道么，协程的实现原理是什么？

协程可以理解为用户态的线程，协程间切换不需要开销

8.数据库学的是MySQL是吧，说说E-R模型

9.数据库的引擎，有什么区别？

10.出了一道题，学生，老师，图书，学生借书需要经过老师的同意，设计表实现第三范式，需要几张表，分别是什么？

 

一面（13min）

1. 介绍比较熟悉的项目

2. 上线了吗

3. 什么是线程安全？

在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。

1. 不安全是什么样的情况？

共享数据异常，程序得不到预期的结果

1. Java 中有哪些方式可以实现线程安全？

在Java里面，最基本的互斥同步手段就是synchronized关键字

除了synchronized之外，我们还可以使用java.util.concurrent名中的重入锁（ReentrantLock）来实现同步，在基本用法上，ReentrantLock与synchronized很相似，他们都具备一样的线程重入特性，只是代码写法上有点区别。不过ReentrantLock比synchronized增加了一些高级功能，主要有以下三项：

• 等待可中断 - 当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情，可中断特性对处理执行时间非常长的同步块很有帮助。
• 公平锁 - 多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁；而非公平锁则不保证这一点，在锁被释放时，任何一个等待锁的线程都有机会获得锁。synchronized中的锁是非公平的，ReentrantLock默认情况下也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁。
• 锁绑定多个条件 - 一个ReentrantLock对象可以同时绑定多个Condition对象，而在synchronized中，锁对象的wait()和notify()或notifyAll()方法可以实现一个隐含的条件，如果要和多于一个的条件关联的时候，就不得不额外地添加一个锁，而ReentrantLock则无须这样做，只需要多次调用newCondition()方法即可。

1. Synchronized 和 Lock 有什么区别？

两者区别：

1.首先synchronized是java内置关键字，在jvm层面，Lock是个java类；

2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；

3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；

4.用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；

5.synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）

6.Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

1. 怎么理解可重入？

1. 可重入的理解：

    可重入的主语是已经获得该锁的线程，可重入指的就是可以再次进入，因此，意思就是已经获得该锁的线程可以再次进入被该锁锁定的代码块。内部通过计数器实现。

java中synchronized关键字和ReentrantLock都是可重入锁。

2. 锁分为可重入锁和不可重入锁。

可重入和不可重入的概念是这样的：当一个线程获得了当前实例的锁，并进入方法A，这个线程在没有释放这把锁的时候，能否再次进入方法A呢？

l  可重入锁：可以再次进入方法A，就是说在释放锁前此线程可以再次进入方法A（方法A递归）。

l  不可重入锁（自旋锁）：不可以再次进入方法A，也就是说获得锁进入方法A是此线程在释放锁钱唯一的一次进入方法A。

狭义的可重入锁指的就是JDK中的ReentrantLock锁。

广义上的可重入锁是具有可重入性的锁，在java 中，synchronized和java.util.concurrent.locks.ReentrantLock都是可重入锁。

下面主要是分析广义的可重入锁：

可重入锁，也叫做递归锁，指的是同一线程外层函数获得锁之后，内层递归函数仍然有获取该锁的代码，但不受影响。

可重入锁最大作用(优点)是避免死锁。缺点:必须手动开启和释放锁。

1. 集群环境下怎么实现线程安全？怎么同步实现？

采用分布式锁

1. 接触过 Redis 吗？

2. 介绍一下 Java 中的 String

3. String 为什么要设置为不可变的？

4. 项目中什么情况下用到多线程？

5. 线程池有什么优势？

6. 有接触过消息队列吗？你觉得消息队列可以解决什么问题？

很年轻的面试官。
先说项目：我先blabla说了一下，面试官说：要不你说一下和软开无关的项目吧，你转行的不可能和cs的死磕项目吧，说一下和这个无关但是能反应你能力的项目吧。我：呃。。。面试官：好那我们就跳过这部分直接刷题吧。
第一题求两个字符串最长公共子序列长度，硬做全ac没啥问题。
第二题求一个数组中和为sum的组合个数，我一开始用的dfs，过了50%
面试官：行，没事，我们再来一道。
我：我想换dp做优化一下。
面试官笑着说：我就是想给你找一道必须用dp的题。
然后第三题求一个数组里和最大的子序列。
做完之后，稍微问了点基础，也没细问，就问我各部分了解程度如何，我说我操作系统和计算机系统结构这块了解比较弱。
最后笑着给我总结：行，刷题没问题，项目太弱了，要回国的话赶紧回来实习吧。
我：毕业前实习不太现实。。。
面试官：我这边让你过了，下一轮自求多福吧。
我：好的好的，谢谢谢谢。。。

 

在线OJ系统做题

8.17的笔试。。。竟然昨天才打电话说今天下午面试。。。等了快一个月。。我还以为自己挂了。。。

两个面试官，穿着zoom的短袖，红蓝双煞。。。红衣服的感觉是主管，大概40多岁，蓝衣服的年轻点。。。面试官拿着简历和笔试成绩卷子来的。。。楼主瞄到自己78分。。。楼主可太菜了。。。。
（1）照例先自我介绍
（2）照例问了一下为啥想来报这个岗位。。。主管感觉了解的挺多啊。。。上来就说我看了你的简历，我的理解是偏向硬件一些吧，为什么考虑来这边呢？然后楼主说了一下。。。然后主管又说，我懂，你们更多是推公式然后来应用，还是写代码踏实。。。有两把刷子啊。。。
（3）照例问了一些问题。。。年轻的面试官说。。现在很多人都上手python，JAVA，为什么你还自己选C++呢？此处Balabala。。。然后面试官接着说，你说到了C++指针和内存泄漏的问题，那你谈一下你的理解吧。。。楼主一套智能指针Balabala。。。
（4）你觉得智能指针最好的思想在哪？Balabala。。。那你实现过智能指针吗？楼主说了unique_ptr和shared_ptr简要的实现，然后说了shared_ptr的问题，包括循环引用，多线程情形下的问题
（5）你说到了多线程，那你谈一下你的理解吧？楼主说了spin lock，mutex->lock_guard->unique_lock一套。。
（6）主管说TCP/IP你说一下吧？HTTP这样的典型的request和response的方式更符合人的习惯，那为什么还需要TCP这样的连接呢？你觉得现在让你来设计一下TCP这个协议，你觉得不足在哪里，你会怎样做呢。。。。。。
（7）另一个补充HTTP，服务端是不知道何时发送完毕的，那么怎么判断接收已经完成了呢？
（8）主管说我看下你的笔试卷吧。。。MD楼主之前看到分数了。。。慌的一批以为要被喷了。。。然后主管放下了，问另一个你还有技术问题想问吗？

另一个说没有了，然后后面就开始聊天了。。。。

 

----------------------------------------------------分割线-------------------------------------------------------

 

楼主真的觉得这个主管涉猎的还挺广的，有些说的还挺实在的。。。

（1）主管介绍了一下zoom和它们部门在做什么。。所有使用的库都是自己写的。。。整个部门没有测试，需要自己测试上线，服务端有bug自己看着办。。。然后两个人笑了，楼主心想这。。。?
（2）主管说还是注重技术和思考，不喜欢PPT吹的飞起，他妈的写个东西不会写的人。。。。这里楼主补刀了一句。。。读研不开心，就是因为老师只会PPT，然后我们三个人都笑了。。。。
（3）主管说你想要做什么方向，有什么规划吗？楼主很实诚的说，其实还是抱着一个学习的姿态，并没有那么明确的职业规划。。。然后主管笑了，说你说的还是挺实在的。。有些面试者觉得想要迎合面试官，就想做报的这个岗位，但面试官都知道什么意思。。。然后接着说，虽然现在是我们两个面试你，但是你进来以后不一定是我们部门，这个也不一定，毕竟也可能有其他原因，包括你拒了我们offer也有可能，然后主管又笑了。。。但是zoom一定有大把的东西能够让你学习

（4）然后主管最后谈到，我们这边流程处理可能比较长，希望你有耐心，包括之前的笔试流程也是。。。然后楼主一顿哭诉。。以为自己黄了。。然后主管说之前在美国出差，回来挑几百份简历选二十来份，花了一定的时间。。。还是要有耐心。。。

 

其他感觉没说什么了，这一面我都不知道算技术？算综合？说后续有问题会通知你。。。全程50min左右

 

1. 自我介绍
2. 实验室项目的内容
3. 使用的框架是什么？
4. spring ioc和aop的含义
5. TCP三次握手的流程
6. 数据库事务有哪些特性

1、原子性（Atomicity）

原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。

2、 一致性（Consistency）

一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。

拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。

3、隔离性（Isolation）

隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。

即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。　

4、持久性（Durability）

持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

1. 你知道的垃圾回收算法
2. 最喜欢哪种数据结构？

 

=
 

2、阿里蚂蚁实习

1. 自我介绍
2. 学校项目用了哪些技术栈
3. spring boot和spring的区别
4. ioc的流程
5. aop的实现原理
6. 说一说你看过的spring cloud源码？？？
7. 四次挥手的流程
8. 为什么需要4次挥手
9. http协议的端口号           80
10. 讲一讲ssh协议的源码？？？
11. Java中的线程创建             四种方法
12. 线程是怎么实现的
13. 线程最底层的数据结构是什么？？？
14. java虚拟机运行的流程
15. 堆区如何分类
16. 垃圾回收有哪些算法
17. java虚拟机的核心设计思想？？？

 

• 自我介绍
• 介绍学校项目1
• 介绍学校项目2
• 介绍知识图谱的逻辑
• 知识图谱怎么生成？
• 非关系型数据库和关系型数据库的区别？

关系型由表和表之间的关系构成

• 事务的四大特性

事务的ACID属性

一般来说，事务是必须满足4个条件（ACID）：：原子性（Atomicity，或称不可分割性）、一致性（Consistency）、隔离性（Isolation，又称独立性）、持久性（Durability）。

原子性：一个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。

一致性：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以自发性地完成预定的工作。

隔离性：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离分为不同级别，包括读未提交（Read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（Serializable）。

持久性：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

在 MySQL 命令行的默认设置下，事务都是自动提交的，即执行 SQL 语句后就会马上执行 COMMIT 操作。因此要显式地开启一个事务务须使用命令 BEGIN 或 START TRANSACTION，或者执行命令 SET AUTOCOMMIT=0，用来禁止使用当前会话的自动提交

• 数据库的隔离级别

四种隔离级别

Read Uncommitted（读取未提交内容）

       在该隔离级别，所有事务都可以看到其他未提交事务的执行结果。本隔离级别很少用于实际应用，因为它的性能也不比其他级别好多少。读取未提交的数据，也被称之为脏读（Dirty Read）。

Read Committed（读取提交内容）

       它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。这种隔离级别 也支持所谓的不可重复读（Nonrepeatable Read），因为同一事务的其他实例在该实例处理其间可能会有新的commit，所以同一select可能返回不同结果。

Repeatable Read（可重读）

       这是MySQL的默认事务隔离级别，它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。不过理论上，这会导致另一个棘手的问题：幻读 （Phantom Read）。简单的说，幻读指当用户读取某一范围的数据行时，另一个事务又在该范围内插入了新行，当用户再读取该范围的数据行时，会发现有新的“幻影” 行。InnoDB和Falcon存储引擎通过多版本并发控制（MVCC，Multiversion Concurrency Control）机制解决了该问题。

Serializable（可串行化） 

       这是最高的隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决幻读问题。简言之，它是在每个读的数据行上加上共享锁。在这个级别，可能导致大量的超时现象和锁竞争。

• 乐观锁与悲观锁的区别

2.乐观锁、悲观锁：

悲观锁：悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）

乐观锁：

乐观锁（ Optimistic Locking ） 相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做（一般是回滚事务）。那么我们如何实现乐观锁呢，一般来说有以下2种方式：

• 三次握手的流程
• 为什么需要3次
• http协议的流程
• http如何保存登录信息
• cookies和session的关系
• 进程和线程的关系
• 进程之间通信的5种方式
• 数组和链表的区别
• hash表插入的流程
• 工厂模式的含义
• 算法题：寻找两个有序数组的中位数。

二面：

1. 知识图谱如何寻找相距一个点距离为2的点
2. http协议如何保证安全性
3. 非对称加密的原理
4. https协议的原理
5. 阻塞式io和非阻塞式io的区别
6. select，poll，epoll的区别
7. 如何加快数据库查询速度
8. 聚集索引和非聚集索引的区别
9. 什么时候不该使用索引？
10. 索引底层的数据结构
11. 了解多少大数据的知识
12. 算法题1：对单链表进行排序
13. 算法题2：给定一个非负整数数组，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。求跳到最后一个位置的最小次数。（跳跃游戏2）

4、携程实习

1. 自我介绍
2. 介绍项目所用的技术栈
3. spring boot的入口是什么？
4. spring boot的数据库中间件
5. spring data jpa底层是什么
6. hibernate和mybatis区别
7. 写代码1：写出hibernate二级缓存源码（我选择死亡）
8. 密码是直接存的吗？
9. 直接存有什么问题？
10. 存数据应该如何加密？
11. Java线程池有哪些参数？
12. 阻塞队列有几种？
13. 拒绝策略有几种？
14. 存1000个数需要多大的HashMap？
15. HashMap的负载因子。
16. int型总共有多少个数字？
17. 设计题：假如有10亿个数，只有一个重复，内存只能放下5亿个数，怎么找到这个重复的数字？
18. 写代码2：寻找单链表的中点（一遍扫描）

• 自我介绍
• 介绍项目
• java有几种基本类型，分别是什么？

java 中有八种基本数据类型。
分别为整型 int，短整型 short，长整型 long，字节型 byte，布尔型 boolean，字符型 char，单精度浮点数 float，双精度浮点数 double。

• spring ioc的作用？
• spring aop异常处理
• 当一段代码被try catch后再发生异常时，aop的异常通知是否执行，为什么？
• 数据库事务的四大特性

原子性，持久性，一致性，隔离性

• java中线程创建有几种方式   

一、继承Thread类创建线程类

二、通过Runnable接口创建线程类

三、通过Callable和Future创建线程

四、线程池

• 讲一讲代理模式
• java的类加载流程
• redis有哪些数据结构
• 序列化的含义
• java序列化的框架有哪些？

序列化：将Java对象转化为字节数组

反序列化：将字节数组转化为Ｊava对象

• 设计题：如何设计一个秒杀系统（服务端、数据库、分布式）

 

二面：

1. 介绍项目
2. 画图1：画出spring MVC图
3. 分别讲解M、V、C的各部分
4. spring boot过滤器
5. spring boot拦截器
6. 画图2：画出spring boot处理一个http请求的全过程
7. 四次挥手的流程
8. 四次挥手中客户端何时关闭
9. time-wait有多久
10. redis内存满了怎么办
11. redis内存淘汰算法除了lru还有哪些
12. 网络协议有哪7层
13. 用过哪些linux命令
14. 算法题：中序遍历非递归

 

技术面：

1. 自我介绍
2. java的三大特性
3. 封装、继承、多态的含义
4. 接口和抽象类的区别

1、都不能被实例化。
2、接口的实现类和抽象类的子类只有全部实现了接口或者抽象类中的方法后才可以被实例化。
不同点：
1、接口只能定义抽象方法不能实现方法，抽象类既可以定义抽象方法，也可以实现方法。
2、单继承，多实现。接口可以实现多个，只能继承一个抽象类。
3、接口强调的是功能，抽象类强调的是所属关系。
4、接口中的所有成员变量 为public static final， 静态不可修改，当然必须初始化。接口中的所有方法都是public abstract 公开抽象的。而且不能有构造方法。抽象类就比较自由了，和普通的类差不多，可以有抽象方法也可以没有，可以有正常的方法，也可以没有。

1. ==和equals的区别
2. jdk和jre的区别

jre是Java运行环境，jdk包括jre以及一些其他工具。

1. TCP和UDP的区别
2. UDP在网络第几层
3. 进程和线程的区别
4. 数组和链表的区别
5. 算法题1：判断二叉树B是否是二叉树A的子树

递归遍历

1. 说出时间复杂度为O(N)的排序算法

桶排序

1. 解释该算法的流程
2. 说出项目用的三种设计模式
3. 分别是怎么用的
4. 看过哪些技术书
5. 都学会了哪些知识
6. 谈谈你对jvm的理解

综合面：

就是和hr面差不多

1. 在项目里干了什么
2. 老师同学的评价
3. 怎么分工
4. 冲突怎么处理
5. 最困难的部分是什么
6. 做的最好的是哪一部分
   我记得问题挺多的，其他的记不住了

 

• 自我介绍
• 项目的内容
• 主要实现了哪些功能
• 登录功能怎么做
• cookies和session的区别
• 注销怎么实现
• 怎么保证同样的账号同一时间只能在一处登录
• 注销了浏览器客户端页面会不会立刻断开
• 为什么游戏里断线页面就立刻会变化
• http协议到底能否保持连接

1.0和1.1

• http协议服务端能不能主动给客户端发消息
• http长连接的内容
• 文件上传如何实现
• 文件下载如何实现
• 如何保证报文的加密传输
• https的原理
• 如何在项目里使用https协议

 

一面：

1. 自我介绍
2. 数据库有几种连接方式
3. 对(a,b,c)加索引，查询ab、ac、bc有没有用？
4. 算法题1：求x的n次方（最优解）
5. 算法题2：整体反转字符串中的所有字母，如 abc(de&fg^h 反转为 hgf(ed&cd^a
6. 算法题3：学生表（id，姓名） 科目表（id，科目名，分数）求每个学生最高分的科目和姓名

二面：

1. 介绍项目
2. 人员权限管理怎么具体实现
3. 索引底层数据结构
4. b加树与b树的区别
5. linux查看ip

ifconfig

1. linux查看内存使用情况

free -h

 

• 算法题：给定一个单链表 L：L0→L1→…→Ln-1→Ln ，
  将其重新排列后变为： L0→Ln→L1→Ln-1→L2→Ln-2→…
  （需要实际的进行节点交换）
• 设计题：10亿篇文章，如何找出其中出现次数最多的100个词。
  备注：你有10台计算机，每台大概都只能存放总数据量的10分之一

 

 

9、深信服星耀计划（实习）

1. 自我介绍
2. 项目功能介绍
3. 画出java运行时内存区结构图
4. 画出堆区的结构图
5. 各区采用什么gc方法
6. CMS收集器的流程
7. 垃圾收集怎么调优
8. 类加载器为什么是组合而不是继承
9. redis有哪些数据结构
10. zset里边存什么
11. 单链表查找复杂度O（n）
12. 能不能更快
13. 画出跳表的结构
14. 描述跳表的构建流程
15. 写出跳表查询的伪代码
16. 写出跳表插入的伪代码
17. 跳表的时间复杂度
18. 写出跳表空间复杂度的推导公式
19. hash加密如何加盐
20. 如何设计好的hash函数     尽可能少发生Hash冲突

 

10、爱奇艺实习

一面：

1. 自我介绍
2. 介绍项目
3. hash加密用的是什么加密算法

当前最常用的哈希算法是MD5和SHA1
4. 三次握手的过程
5. syn和ack号码的关系

第一次握手：主机A发送位码为syn＝1，随机产生seq number=1234567的数据包到服务器，主机B由SYN=1知道，A要求建立联机；

第二次握手：主机B收到请求后要确认联机信息，向A发送ack number=(主机A的seq+1)，syn=1，ack=1，随机产生seq=7654321的包；

第三次握手：主机A收到后检查ack number是否正确，即第一次发送的seq number+1，以及位码ack是否为1，若正确，主机A会再发送ack number=(主机B的seq+1)，ack=1，主机B收到后确认seq值与ack=1则连接建立成功。
6. http get和post的区别
7. java反射可以获得类的什么？
8. 乐观锁和悲观锁的区别
9. where和having的区别
10. redis持久化的方法
11. java volatile关键字

保证内存可见性
12. spring的入口什么？
13. List、set、Map的区别
14. linux查看进程

ps-aux，top

二面：

1. java运行时数据区
2. 程序计数器的作用
3. 虚拟机栈里放了什么
4. 类加载器的双亲委派
5. 为什么需要双亲委派
6. redis主从结构
7. redis哨兵的作用
8. 从浏览器中输入url之后发生了什么
9. ConcurrentHashMap的实现
10. java线程有多少种状态

  通过查看State源码，线程共有6种状态：

NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED

分别对应于

新建、运行、阻塞、等待、带超时的等待、终止

11. wait和sleep的区别
12. java线程通信同步有几种方式

1、传统的线程通信。

    在synchronized修饰的同步方法或者修饰的同步代码块中使用Object类提供的wait(),notify()和notifyAll()3个方法进行线程通信。

    关于这3个方法的解释：

    wait():导致当前线程等待，直到其他线程调用该同步监视器的notify()方法或notifyAll()方法来唤醒该线程。
    notify():唤醒在此同步监视器上等待的单个线程。
    notifyAll():唤醒在此同步监视器上等待的所有线程。
2、使用Condition控制线程通信。

    当程序使用Lock对象来保证同步，系统不存在隐式的同步监视器，只能用Condition类来控制线程通信。

     await():类似于隐式同步监视器上的wait()方法，导致当前线程等待，直到其他线程调用该Condition的signal()方法或signalAll()方法来唤醒该线程。
    signal():唤醒在此Lock对象上等待的单个线程。如果所有的线程都在该Lock对象上等待，则会选择唤醒其中一个线程。选择是任意性的。
    signalAll():唤醒在此Lock对象上等待的所有线程，只有当前线程放弃对该Lock对象的锁定后，才可以执行被唤醒的线程。

3、使用阻塞队列（BlockingQueue）控制线程通信（也实现了生产者消费者模式）

    BlockingQueue提供如下两个支持阻塞的方法：
    put(E e):尝试把E元素放入BlockingQueue中，如果该队列的元素已满，则阻塞该线程。
    take():尝试从BlockingQueue的头部取出元素，如果该队列的元素已空，则阻塞该线程。
13. java4种线程池分别是什么
14. CMS收集器和G1收集器的区别
15. spring bean的生命周期
16. 精通哪些消息队列？？？
17. 精通哪些大数据工具？？？
18. 精通哪些分布式框架？？？

 

现场技术面：

2个面试官轮流提问。
1、自我介绍
2、每个项目都做了什么
（那时候我还没去实习，写了好多项目，小的也写上了）
3、知识图谱如何实现。
4、面向对象的特性。（封装、继承、多态）
5、接口和抽象类的区别。
6、事务的特性。

一般来说，事务是必须满足4个条件（ACID）：：原子性（Atomicity，或称不可分割性）、一致性（Consistency）、隔离性（Isolation，又称独立性）、持久性（Durability）。
7、三次握手四次挥手。
8、进程和线程的区别。
9、说说你知道哪些数据结构？
10、项目中用了哪些设计模式？
11、都是怎么用的？
12、解释装饰器模式？（之前没说这个）
13、设计题：10亿个数快速寻找中位数

 

12、vivo提前批后端

技术面：软件工程师（后端方向）

1、自我介绍。
2、介绍项目。
3、介绍所用技术。
4、对string类的理解。接口和抽象类的区别。
5、静态变量存放在内存哪个区域？
6、有一个public static final的HashMap，里边对象的属性能不能修改？
7、说出6种常见的java异常。
8、多线程如何保持同步？
9、java可见性的关键字及其原理。

volatile
10、HashMap的实现原理、ConcurrentHashMap的结构、插入和查询的流程。
11、怎么查看java虚拟机内存占用？
12、JAVA内存如何分配？
13、堆区内存如何分配？
14、程序计数器的作用？
15、垃圾回收算法和流程。
16、如何减少full gc的次数？
17、方法区是否需要gc
18、类加载的流程。
19、知道哪些类加载器。
20、类加载器之间的关系？
21、双亲委派模型。为什么使用双亲委派模型？
22、mysql有几种锁？怎么实现？
23、mysql mvcc？
24、你用的mysql存储引擎？为什么选择它？实现原理？
25、innodb事物的级别
26、b加树的结构？与二叉树的区别？与b树的区别？

b+树是m阶平衡树
27、redis数据结构？单线程还是多线程？
28、cpu密集型多线程和io密集型多线程的比较。
29、cpu密集型里如何管理多线程？
30、用什么样的线程池和阻塞队列？
31、cpu线程特别多会产生什么问题？
32、io密集型里怎么减少需要的线程数？
33、io多路复用的原理和实现。
34、这个还不够，怎么减少处理io（和磁盘io交互）所需要的线程？
35、用什么样的队列？你是怎么实现？
36、（我回答的redis的list实现的）这种队列有什么缺点？
37、既然有这样问题，为什么不用rabbitmq？（我说我偷懒了。。。）
38、io量很大，队列很长怎么办？
39、如何分布式存储？
40、你还有什么问题问我？

 

 

13、OPPO提前批

一面：技术面

问基础知识，不是特别简单，需要知道一些原理和实现。整体难度和vivo类似。
涉及到网络协议、mysql、多线程、类加载、gc、hashmap、红黑树、b加树、手写设计模式、spring启动原理等方面的各种知识。

二面：部长面

详细询问简历上的内容，包括科研，项目和实习。从你用的模型，框架，数据库，缓存等各方面仔细地问，包括原理还有实现，还会给项目出新的情景问题（需求）问你的解决方案。还有关于redis和mysql的各方面包括实际应用问了很多。

 

14、百度提前批

一面

1. 介绍学校项目以及提问
2. 四次挥手的过程
3. HashMap的实现原理
4. Hash冲突
5. Hashmap插入过程
6. ArrayList和LinkedList的区别
7. Java内存模型
8. 大对象放在哪个内存区域
9. GC的方法有哪些
10. 栈中存放什么数据
11. 哪些对象可以作为GC Root
12. 查看GC状态的命令
13. Java怎么实现多线程？
14. Java创建线程的方法？
15. Futuretask和callable的区别？
16. Callable和runnable的区别？
17. 线程池分几种？拒绝策略有哪些？
18. Synchronized和Reentrantlock的区别，分别怎么实现
19. CAS的含义

Compare And Swap

1. Mysql知道几种存储引擎，有什么区别
2. Innodb的行级锁的实现
3. Innodb的行级锁有几种
4. Innodb的隔离级别
5. 事务的特性

一般来说，事务是必须满足4个条件（ACID）：：原子性（Atomicity，或称不可分割性）、一致性（Consistency）、隔离性（Isolation，又称独立性）、持久性（Durability）。

1. 数据库怎么优化
2. 索引的数据结构
3. 讲一讲b+树
4. b+树有哪些优点
5. Redis的数据结构
6. Redis为什么快？
7. Redis单线程还是多线程，为什么？
8. Redis分布式锁
9. spring boot和spring的区别
10. 讲一讲对spring的认识（ioc、aop？）
11. Spring aop实现原理
12. Spring动态代理默认用哪一种
13. 说说你熟悉的设计模式
14. 说说适配器模式
15. Rpc了解吗？
16. Hadoop了解吗？
17. 写代码：写出spring jdk动态代理的实现。

 

二面

1. 介绍实习以及提问
2. TCP/IP协议四层模型
3. 线程池的参数和含义
4. 线程池有几种
5. newCachedthreadpool线程无限多会怎么样？
6. 说一说对concurranthashmap的原理
7. concurranthashmap和hashtable的区别。

hashtable 是整个数据结构全部锁住

1. 了解TreeList吗？底层实现？
2. 说一说你了解的红黑树。
3. CAS的原理

compare and swap

1. i加加是不是原子操作，为什么

不是，i++底层由三步操作构成

1. Mysql mvcc
2. 版本号各有什么用？
3. 带版本号时的插入删除过程是什么？
4. Innodb默认隔离级别
5. 脏读和幻读的区别是什么？
6. GC的全流程
7. GC中老年代用什么回收方法？
8. 说一说策略模式。
9. Linux如果cpu满了，用什么命令?
10. 找到线程之后用什么命令？
11. 算法题1：二叉树前序遍历非递归
12. 算法题2：链表如何判断有环，链表有环求长度

 

15、顺丰sp专场

1. 介绍实习做了什么？
2. Java的基本类型
3. String是基本类型吗？
4. String、Stringbuffer和StringBuilder的区别
5. 介绍项目做了什么？
6. 线程的实现方式
7. 线程有哪些方法？
8. Wait()是线程的方法吗？Object
9. 项目中使用多线程的场景
10. 是自己手写的吗？
11. mysql分页
12. Mybatis占位符
13. 算法题：如何判断一个数是不是2的整数次幂？

16、shopee后端

一面：

1. 介绍实习内容和你做了什么
2. 进程和线程的区别
3. 多线程如何同步
4. 线程同步的实现方式（抛开语言，操作系统里）
5. 讲一讲线程死锁

产生死锁的必要条件：

互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。
请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
环路等待条件：在发生死锁时，必然存在一个进程--资源的环形链。

1. 如何避免线程死锁

通过设置某些限制条件，去破坏死锁的四个条件中的一个或几个条件，来预防发生死锁。但由于所施加的限制条件往往太严格，因而导致系统资源利用率和系统吞吐量降低。

1. 操作系统的线程/进程调度
2. 说三种排序算法（快排、堆排、归并）
3. 讲一下其中两种的原理（堆排、归并）
4. 算法1：手撕快排
5. 算法2：有环链表求环长度
6. TCP和UDP的区别
7. 说UDP的一个实际应用场景    DNS域名解析
8. TCP的流量和拥塞控制
9. 讲一讲ARP协议

通过广播方法将IP地址解析为MAC地址

1. Mysql事务

一、事务定义
Transaction
事务：一个最小的不可再分的工作单元；通常一个事务对应一个完整的业务(例如银行账户转账业务，该业务就是一个最小的工作单元)
一个完整的业务需要批量的DML(insert、update、delete)语句共同联合完成
事务只和DML语句有关，或者说DML语句才有事务。这个和业务逻辑有关，业务逻辑不同，DML语句的个数不同

• 原子性(A)：事务是最小单位，不可再分
• 一致性(C)：事务要求所有的DML语句操作的时候，必须保证同时成功或者同时失败
• 隔离性(I)：事务A和事务B之间具有隔离性
• 持久性(D)：是事务的保证，事务终结的标志(内存的数据持久到硬盘文件中)

1. Mysql事务是怎么实现的

 

1. Mysql的隔离级别

四种隔离级别

Read Uncommitted（读取未提交内容）

       在该隔离级别，所有事务都可以看到其他未提交事务的执行结果。本隔离级别很少用于实际应用，因为它的性能也不比其他级别好多少。读取未提交的数据，也被称之为脏读（Dirty Read）。

Read Committed（读取提交内容）

       它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。这种隔离级别 也支持所谓的不可重复读（Nonrepeatable Read），因为同一事务的其他实例在该实例处理其间可能会有新的commit，所以同一select可能返回不同结果。

Repeatable Read（可重读）

       这是MySQL的默认事务隔离级别，它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。不过理论上，这会导致另一个棘手的问题：幻读 （Phantom Read）。简单的说，幻读指当用户读取某一范围的数据行时，另一个事务又在该范围内插入了新行，当用户再读取该范围的数据行时，会发现有新的“幻影” 行。InnoDB和Falcon存储引擎通过多版本并发控制（MVCC，Multiversion Concurrency Control）机制解决了该问题。

Serializable（可串行化） 

       这是最高的隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决幻读问题。简言之，它是在每个读的数据行上加上共享锁。在这个级别，可能导致大量的超时现象和锁竞争。

1. 算法3：求二叉树两个节点的最近公共父节点

二面：

1. 跳台阶问题（思路和理由）
2. 聊实习和项目做了什么工作（详细）
3. 然后开始聊人生。。。
4. 老师对你的评价（最好/最坏）
5. 同学对你的评价（最好/最坏）
6. 实习的收获
7. 喜欢什么样的工作？
8. 对未来的规划
9. 对shopee了解多少？
10. 反正各种类似于hr面的问题，时间久了我也记不太清了

 

17、远景智能sp专场

一面：

1. 多态的含义
2. 反射的作用
3. 反射的实现
4. 事务的ACID

原子性：一个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。

一致性：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以自发性地完成预定的工作。

隔离性：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离分为不同级别，包括读未提交（Read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（Serializable）。

持久性：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

在 MySQL 命令行的默认设置下，事务都是自动提交的，即执行 SQL 语句后就会马上执行 COMMIT 操作。因此要显式地开启一个事务务须使用命令 BEGIN 或 START TRANSACTION，或者执行命令 SET AUTOCOMMIT=0，用来禁止使用当前会话的自动提交。

1. 事务的隔离界别

事务隔离级别	脏读	不可重复读	幻读
读未提交（read-uncommitted）	是	是	是
不可重复读（read-committed）	否	是	是
可重复读（repeatable-read）	否	否	是()
串行my化（serializable）	否	否	否

1. 了解socket吗？
2. Socket可能超时的情况
3. Websocket和socket的区别？
4. http如何保存状态
5. Cookie和session的区别
6. 多播和广播的区别
7. 观察者模式
8. 策略模式
9. 设计模式的开/闭原则
10. 算法题1：连续子数组最大和
11. 算法题2：二叉树的右视图

二面：

1. 介绍实习
2. 实习你做了哪些内容
3. xml上传的实现方式
4. 为何需要三步
5. 重新设计整个项目上传功能
6. 实习中用到了哪些设计模式
7. 分别在什么功能里用
8. 梳理类与类之间的关系
9. 掌握哪些框架
10. redis在项目里怎么用
11. 具体怎么写，增删改查流程是什么
12. 分布式准备拿什么框架做
13. 对java虚拟机的理解
14. java7和8的两个区别
15. 为什么hashmap链表要转红黑树
16. 为什么长度超过8转
17. 为什么要把字符串常量池放到堆区
18. java8方法区的变化

 

18、猿辅导服务器开发

一面：

1、你在项目在遇到过最困难的事。
2、操作系统、网络原理、编译原理。。。你最擅长哪个？（网络？）
3、浏览器的地址栏里输入一个url，点一下回车，会发生什么？
（1）浏览器怎么得到url？
（2）DNS解析是发送整个url吗？
（3）DNS解析详细过程。
（4）TCP三次握手之前需要什么？
（5）ARP解析过程。
（6）ip怎么寻址？
（7）TCP第三次握手的作用是什么？
（9）TCP连接建立之后呢？
4、算法题：单链表，翻转n-m段链表。
5、算法题：给出有序数组和target求距离target最小的位置（min distance index）。

二面：

1、自我介绍。
2、重点介绍实习内容以及你做的工作内容？（详细）
3、人员权限管理模块怎么设计？
4、sql题：
student：id, name, age
student_score: id,student_id, course_id, score
平均成绩前三的student_id, name
5、数据库索引的数据结构。
6、b加树和b树的区别。
7、为什么索引用b加树而不用红黑树？

减少IO次数，数据全在根节点
8、死锁的条件。

产生死锁的四个必要条件：

（1） 互斥条件：一个资源每次只能被一个进程使用。

（2） 占有且等待：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

（3）不可强行占有:进程已获得的资源，在末使用完之前，不能强行剥夺。

（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之

一不满足，就不会发生死锁。
9、如何设计来避免死锁。

*死锁预防：通过设置某些限制条件，去破坏死锁的四个条件中的一个或几个条件，来预防发生死锁。但由于所施加的限制条件往往太严格，因而导致系统资源利用率和系统吞吐量降低。

*死锁避免：允许前三个必要条件，但通过明智的选择，确保永远不会到达死锁点，因此死锁避免比死锁预防允许更多的并发。

10、算法题：求连续子数组最大和以及对应子数组的首尾坐标。

三面：

1、自我介绍。
2、重点介绍学校项目的内容。
3、介绍自己做的内容（详细）。
4、画图：3个后端模块画项目流程图（详细）。
5、讲后端流程中每一部分怎么实现。
6、各部分怎么保证多线程安全。
7、Redis一致性怎么保证。
8、Redis分布式锁的原理。
9、你所了解的分布式一致性算法。
18、设计题：有一个二维坐标系上有10亿个点，给定一个圆，如何快速得出哪些点在圆中（返回点集）？

19、拼多多学霸批服务端

一面：

1.自我介绍
2.在实习中都做了什么？（详细）
3.学过哪些课？编译原理课的内容
4.笔试题第一题思路
5.笔试题第二题思路
6.网络7层模型
7.Tcp和udp位于哪一层
8.Ip寻址流程
9.Tcp和udp的区别
10.进程和线程的区别
11.Java调度进程和线程
12.Hashmap的结构
13.String和Stringbuffer的区别
14.你用过哪些设计模式
15.静态代理实现
16.动态代理实现
17.观察者模式
18.观察者模式的使用场景

19.e-r图
20.Jvm内存区域划分
21.一个对象从进入堆区到死亡的全流程
22.数据库索引的实现
23.介绍B+树
24.数据库两种存储引擎的区别
25.为什么myisam不支持行锁
26.写代码：

• 记录：id, status
• 存储：256库*256表
• 场景：需要扫描所有数据，找出所有status=2的id列表
• 要求：同一份代码，部署20台服务器，速度快，且每一张表不会被扫描2次

27.大学期间遇到过最大的困难以及解决？
28.为什么选择读计算机？
29.为什么不考公务员？
30.以后想做的方向
31.10年以后的设想

10.Spring aop怎么实现？
11.Mysql索引的实现
12.使用b加树的理由
13.B加树做索引比红黑树好在哪里？
14.项目里Redis怎么用
15.分布式缓存可能出现的问题
16.分布式锁
17.Setnx加锁的原理
18.怎么解除分布式锁？
19.Jvm内存区域划分
20.程序计数器的作用
21.本地方法栈和虚拟机栈的区别
22.Gc全流程
23.Gc算法
24.连接过程中什么时候会出现time_wait状态

服务器太忙
25.为什么要有time_wait状态
26.一致性hash了解吗？

一致性hash算法解决的核心问题是，当solt数发生变化的时候能够尽量少的移动数据。该算法最早在《Consistent Hashing and Random Trees:Distributed Caching Protocols for Relieving Hot Spots on the World Wide Web》一文中被提出。它能够在添加/移除一台缓存服务器的时候，尽可能小的改变已存在key的映射关系，避免大量key的重新映射。
27.一致性hash的优点？

28.设计题：有一个服务器专门接收大量请求，怎么设计？

IO多路复用
29.同步和异步的区别
30.非阻塞io和阻塞式io的区别
31.http如何保持连接
32.如果不用http，如何保持连接
33.Volatile 关键字的作用
34.Volatile 关键字的实现
35.用户态和内核态的区别
36.lru了解吗？
37.怎么实现lru？
38.布隆过滤器了解吗？
39.算法题：二叉树前序遍历非递归

---

9月

一鼓作气，再而衰，三而竭，8个月的校招大作战也该结束了。面完华为我就停止了面试。

20、华为西研所通用软开

一面：

 

1. static有哪些作用？
2. 说几种排序算法（快排、堆排、归并）
3. 画图讲解堆排序的全过程
4. 手撕代码1：求n！
5. 手撕代码2：反转字符串中的每个小字符串并输出，输入的字符串中有下划线。
   如abc_def_gh，反转后的结果cba_fed_hg​​​​​​​
6. 手撕代码3：求二叉树所有叶子结点的和
7. 手撕代码4：手写单例模式

二面：

1. 加盐hash加密算法的流程
2. 为什么要用Redis
3. 有缓存情况下查询的流程
4. 有缓存情况下修改的流程
5. spring boot和spring 的区别
6. aop如何实现
7. 动态代理有几种
8. 静态代理和动态代理的区别
9. 动态代理与反射
10. 项目如何进行分布式部署
11. spring cloud如何进行配置
12. 缓存命中率低会发生什么？
13. 如何解决缓存穿透？
14. 怎么样过滤掉不存在的key值？
15. 布隆过滤器的原理
16. gc的过程
17. system.gc()是否可以立刻出发gc
18. 如何立刻触发gc()
19. 描述二叉树如何实现dps和bfs（非递归）
20. dfs和bfs的区别
21. 各自举出一个只能用dfs和bfs的场景
22. 手撕代码1：
    以下代码是否有问题？
    有什么问题？
    补充代码解决这个可能的问题。

    1 2 3 4 5 6 7 8 9

    public class A{ int val; A(int x){this.val=x;} } A a=new A(1); A b=new A(1); HashMap<A,Integer> map=new HashMap<A,Integer>(); map.put(a,1); map.put(b,1);

 

1. 手撕代码2：输出以1开始的n个正整数(1,2,...,n)的第k个排列。（要求回溯法）