0086 shopee面试题汇总
shopee 后端面试题目
1、我的大数据方向
leetcode hard 寻找两个有序数组的中位数
了解MVCC吗
MVCC：多版本并发控制。
特点
1.MVCC其实广泛应用于数据库技术，像Oracle,PostgreSQL等也引入了该技术，即适用范围广
2.MVCC并没有简单的使用数据库的行锁，而是使用了行级锁，row_level_lock,而非InnoDB中的innodb_row_lock.
基本原理：MVCC的实现，通过保存数据在某个时间点的快照来实现的。这意味着一个事务无论运行多长时间，在同一个事务里能够看到数据一致的视图。根据事务开始的时间不同，同时也意味着在同一个时刻不同事务看到的相同表里的数据可能是不同的。
- Mysql两种引擎对比
| InnoDB | myisam | |
|---|---|---|
| 储存方式 | 聚集索引（B+树存储索引和数据） | 非聚集（B+树存储索引;数据表存数据） |
| 事务安全 | 事务安全 | 非事务安全 |
| 锁 | 表锁、行锁 | 表锁 |
| 全文索引 | 不支持（5.5之前） | 支持 |
| 外键 | 支持 | 不支持 |
| 事物处理，具有ACID（原子性，一致性，隔离性，持久性）事物支持等特性，如果在应用中大量使用insert和update操作，应选用InnoDB。 | 管理非事物表，提供高速存储和检索以及全文搜索的能力，如果在应用中执行大量的select操作，应选用MyISAM |
脏读 幻读 不可重复读
脏读：读取另一个事务未提交的数据
幻读：同样的条件，第一次和第二次读出来的记录条数不一样。（新增或删除）。
不可重复读：同样的查询条件，查询到的结果都不一样（中间有对数据进行了修改）。
bonus：
1、事务的四种隔离级别：读取未提交、读取已提交、可重复读，串行化
| 事务隔离级别 | 脏读 | 不可重复读 | 幻读 |
|---|---|---|---|
| 读未提交（read-uncommitted） | 是 | 是 | 是 |
| 读取已提交（read-committed） | 否 | 是 | 是 |
| 可重复读（repeatable-read） | 否 | 否 | 是 |
| 串行化（serializable） | 否 | 否 | 否 |
2、MySQL默认隔离级别：可重复读，因此只会出现幻读。
- 进程间通信方式，常用的哪种
进程间通信方式
信号量、共享内存、无名管道、命名管道(FIFO)、消息队列、套接字、全双工管道
后两者适用于远程通信，适合网络编程。
bonus：
1、全双工管道：数据通讯是双向的，int pipe(int fd[]); fd[0]/fd[1]分别对应：读、写；
三次握手：
- 第一次：客户端发送初始序号x和syn=1请求标志
- 第二次：服务器发送请求标志syn，发送确认标志ACK，发送自己的序号seq=y，发送客户端的确认序号ack=x+1
- 第三次：客户端发送ACK确认号，发送自己的序号seq=x+1，发送对方的确认号ack=y+1
三次握手
四次挥手过程分析
第一次：客户端请求断开FIN,seq=u
第二次：服务器确认客户端的断开请求ACK,ack=u+1,seq=v
第三次：服务器请求断开FIN,seq=w,ACK,ack=u+1
第四次：客户端确认服务器的断开ACK,ack=w+1,seq=u+1
为什么要三次握手四次挥手，两次握手三次挥手不行吗？
三次握手原因：考虑到因为网络导致的报文失效情况。客户端发出请求，因网络原因延迟很久，客户端认为这条失效，而服务端在某个时刻受到，它将回应，但是客户端不会理会这个回应（失效），于是服务端就等着客户端发请求，就会白白浪费服务端资源；
四次挥手原因：为了保证数据完整传输。服务端的数据可能还没有全部被客户端受到。
Http状态码，1.2.3.4.5开头的啥意思
| 分类 | 分类描述 |
|---|---|
| 1** | 信息，服务器收到请求，需要请求者继续执行操作 |
| 2** | 成功，操作被成功接收并处理 |
| 3** | 重定向，需要进一步的操作以完成请求 |
| 4** | 客户端错误，请求包含语法错误或无法完成请求 |
| 5** | 服务器错误，服务器在处理请求的过程中发生了错误 |
常用的：
- 200 - 请求成功
- 301 - 资源（网页等）被永久转移到其它URL
- 404 - 请求的资源（网页等）不存在
- 500 - 内部服务器错误
- 502 - 网关错误 Bad Gateway
- 504 - 响应超时 Gateway Time-out
Hashmap底层原理
解决哈希冲突的方法
链式分离法、开放地址法，双哈希法、溢出表
数组和链表的区别
kafka原理讲一下
kafka的topic与partition关系
Kafka消息是否有序
Hdfs数据存储过程是怎样的
Hadoop的map reduce过程是怎样的
Spark有哪几种算子
Spark的shuffle过程是怎样的
如何解决spark的数据倾斜
Spark 如何优化两个大小表的jion操作
大数据中寻找top-K的方法 （小顶堆），算法复杂度？（nlogK）
二面：
算法，寻找奇点
LeetCode 162
反射了解吗？使用场景？
反射是指运行中的java程序能动态获取类的方法、属性、构造函数。
反射的流程：
1、获取指定名称的Class对象，方法有：Class.forName()、obj.getClass()、类名.class()
2、实例化对象，获取类的方法、属性和构造函数；
3、访问属性、方法、调用构造函数创建对象。
应用场景：
1、反编译：.class --> .java
2、Spring IoC
3、Tomcat服务器（IO、ServerSocket、反射）
反射的优缺点：
优点：运行期类型的判断，动态加载类，提高代码灵活度，提高了应用程序的***可扩展性***；
缺点：反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的java代码要慢很多（性能问题）。
序列化及其使用场景
序列化：将对象写入到IO流中
private static void serialize(String filename) throws IOException {
File f = new File(filename); // 定义保存路径
OutputStream out = new FileOutputStream(f); // 文件输出流
ObjectOutputStream oos = new ObjectOutputStream(out); // 对象输出流
oos.writeObject(new Person("Jack", 30, Sex.MALE)); // 保存对象
oos.close();
out.close();
}
反序列化：从字节流中恢复对象
private static void deserialize(String filename) throws IOException, ClassNotFoundException {
File f = new File(filename); // 定义保存路径
InputStream in = new FileInputStream(f); // 文件输入流
ObjectInputStream ois = new ObjectInputStream(in); // 对象输入流
Object obj = ois.readObject(); // 读取对象
ois.close();
in.close();
}
实现过程的关键细节：
1、serialVersionUID 用于控制序列化版本是否兼容
2、序列化时需要实现Serializable接口
序列化的使用场景：
1、将对象保存到内存、文件、数据库；
2、网络上传输对象时；
3、远程方法调用时（RMI）
不需要序列化的字段：transient
强制序列化：Externalizable
如果已经序列化过了，直接读取序列号。
java流的生成方式
1、使用数组：Stream stream = Stream.of(arr);
2、列表List：Stream stream = list.stream();
3、使用Stream.generate()
4、使用 Stream.iterate()
5、Pattern.compile().splitAsStream()
StringBuffer、StringBuilder、String区别
String：不可变字符，线程不安全
StringBuffer：可变字符串，线程安全
StringBuilder：可变字符串，线程不安全
2、java后端面经
java如何实现并发
1、继承Thread类，重写run（）方法；
2、实现Runnable接口，实现run（）方法；
3、实现Callable接口，实现call（）方法。
java哈希表
hashtable在Hashmap基础上，对整个桶加锁方法，效率低。
java的Treemap
继承AbstractMap，实现了SortedMap，在未指定比较器时，键按照字典序比较。
TreeMap底层是红黑树，增删改复杂度O(logn)
java的concurrentHashMap
concurrentHashMap在HashMap基础上，增加了一个segments数组，数组中每个元素是一个segment，对应一个HashMap；每个segment是独立的，因此在加锁时，只需要锁住某个段即可（分段锁），提高了操作效率。
concurrentHashMap的最大并发数等于segments的个数。
hashtable加锁的时候对整个数据结构加，其所有操作都被锁保护，因此效率低，。
聚簇索引与非聚簇索引
聚簇索引：将数据存储与索引放到了一块，找到索引也就找到了数据，叶子结点是就是整行数据，唯一的
非聚簇索引：将数据存储与索引分开结构，索引结构的叶子节点指向了数据的对应的行
http1和http2
http2是二进制传输，http1是文本传输；http2支持多路复用；http2通过压缩头部然后再发送；http2支持在客户端未经请求许可情况下主动向客户端推送内容。
tcp udp区别
| UDP | TCP | |
|---|---|---|
| 1、是否连接 | 无连接 | 面向连接 |
| 2、是否可靠 | 不可靠传输，不使用流量控制和拥塞控制 | 可靠传输，使用流量控制和拥塞控制 |
| 3、连接对象个数 | 支持一对一，一对多，多对一和多对多交互通信 | 只能是一对一通信 |
| 4、传输方式 | 面向报文 | 面向字节流 |
| 5、首部开销 | 首部开销小，仅8字节 | 首部最小20字节，最大60字节 |
| 6、适用场景 | 适用于实时应用（IP电话、视频会议、直播等） | 适用于要求可靠传输的应用，例如文件传输 |
tcp 如何保证可靠性
1、校验和：在数据传输的过程中，将发送的数据段都当做一个16位的整数。将这些整数加起来。并且前面的进位不能丢弃，补在后面，最后取反，得到校验和；校验和一致，不一定传输成功，不一致一定有误。
2、确认应答与序列号
3、超时重传：时间到达没有接收到ACK报文，那么对刚才发送的数据进行重新发送（有去重丢弃操作）
4、连接管理：连接管理就是三次握手与四次挥手的过程
5、流量控制：在TCP协议的报头信息当中，有一个16位字段的窗口大小，窗口大小的内容实际上是接收端接收数据缓冲区的剩余大小；
6、拥塞控制：拥塞窗口的概念。发送刚开始定义拥塞窗口为 1，每次收到ACK应答，拥塞窗口加 1；当拥塞窗口大小超过阈值时，不能再按照指数来增长，而是线性的增长。在慢启动开始的时候，慢启动的阈值等于窗口的最大值，**一旦造成网络拥塞，发生超时重传时，慢启动的阈值会为原来的一半（**这里的原来指的是发生网络拥塞时拥塞窗口的大小），同时拥塞窗口重置为 1。
三次握手
restful编程风格
URL 接口 请求方式 解释
1 /user getUsers get 查询所有用户
2 /user/{id} getUserById get 通过ID查询用户
3 /user addUser post 添加用户
4 /user/{id} updateUserById put 通过ID修改用户
5 /user/{id} deleteUserById delete 通过ID删除用户
POST、GET、PUT、DELETE
- get---->>>查询
- post–>>>添加
- put---->>>修改
- delete->>>删除
思考题：如何实现微信的二维码登陆
二维码登录模块设计
CAS（Central Authentication Service）：为 Web 应用系统提供一种可靠的单点登录解决方法
安全性问题：
-
生成二维码网关
在页面上对生成二维码有严格性能要求，同一ip每秒只允许生成3次，超过此限制，返回过于频繁，自动失败。 -
授权登录（APP）网关
在页面上对授权有严格性能要求，同一ip每分钟只允许登录1次，超过此限制，返回过于频繁，自动失败。
3、面经
三握手四挥手 及 其状态
什么是平衡二叉树
定义：
①任意一个节点的左右子树高度差的绝对值不超过的1；
②任意节点的左右子树都是平衡二叉树的二叉查找树。
③左子树小于根节点，右子树大于根节点
④自平衡：平衡因子，旋转
实现反转链表
1、递归
public Node reverse(Node head) {
if (head == null || head.next == null)
return head;
Node temp = head.next;
Node newHead = reverse(head.next);
temp.next = head;
head.next = null;
return newHead;
}
2、迭代
public static Node reverseList(Node node) {
Node pre = null;
Node next = null;
while (node != null) {
next = node.next;
node.next = pre;
pre = node;
node = next;
}
return pre;
}
MySQL复合索引
复合索引是N个字段组合成一个索引的。Mysql从左到右的使用索引中的字段，一个查询可以只使用索引中的一部份，但只能是最左侧部分；因此符合索引时，必须包好最左字段。
set的使用场景，有序set的使用场景
有序集去重的场景
1、 排行榜：有序集合经典使用场景。例如视频网站需要对用户上传的视频做排行榜，榜单维护可能是多方面：按照时间、按照播放量、按照获得的赞数等。
2、用Sorted Sets来做带权重的队列，比如普通消息的score为1，重要消息的score为2，然后工作线程可以选择按score的倒序来获取工作任务。让重要的任务优先执行。
反射
任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，动态获取信息以及动态调用对象方法的功能称为java语言的反射机制
使用场景：动态类加载，动态代理，反编译，Tomcat服务器。
缺点：性能是一个问题，反射相当于一系列解释操作，通知jvm要做的事情，性能比直接的java代码要慢很多。
进程调度算法
先来先服务：先来后到
时间片轮转：先来先服务，但是只运行一个时间片（如100ms）
短作业优先 ：从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行
最短剩余时间：选择预期剩余时间最短的进程
高响应比：R=(w+s)/s （R为响应比，w为等待处理的时间，s为预计的服务时间）
优先级：从后备作业队列中选择优先级最髙的一个或几个作业，将它们调入内存
多级反馈队列：既能使高优先级的作业得到响应又能使短作业（进程）迅速完成
进程间怎么通信
信号量、无名管道、有名管道、共享内存、socket、全双工模式通信
线程间通信
-
wait()、 notify() 、notifyAll()
-
volatile ：多个线程同时监听一个变量
-
CountDownLatch ：维护了一个线程间共享变量state
-
LockSupport : 实现线程间阻塞和唤醒的工具，需要知道线程的名字。
事务隔离级别
隔离级别 脏读 不可重复读 幻读
未提交读（Read uncommitted） 可能 可能 可能
已提交读（Read committed） 不可能 可能 可能
可重复读（Repeatable read） 不可能 不可能 可能
可串行化（Serializable ） 不可能 不可能 不可能
MyISAM和InnoDB差别
底层：MyISAM是非聚簇索引，即索引和数据分开存储，叶子节点是行的索引；InnoDB是聚簇索引，索引和数据放在一起，叶子节点是整行数据；
MyISAM不支持事务，InnoDB支持。MyISAM不支持行锁，只支持表锁，InnoDB支持行锁。
InnoDB没有保存具体的行数，所以在统计行数的时候会扫描全表；MyISAM有保存。
myisam的索引以表名+.MYI文件分别保存。innodb的索引和数据一起保存在表空间里。
Linux kill命令
在Linux/unix下，中止一个Java进程有两种方式，一种是kill -9 pid，一种是kill -15 pid（默认）。
SIGNKILL（9） 的效果是立即杀死进程. 该信号不能被阻塞, 处理和忽略。立即杀死
SIGNTERM（15） 的效果是正常退出进程，程序可能仍然继续运行
4、面经
mysql 有那些存储引擎，有哪些区别
mysql 索引在什么情况下会失效
innodb 与myisam 的区别？
mysql 的索引模型
1、有序数组：指定一个列为索引，然后按照这个列的值排序，以有序数据存放入数据表中
2、哈希表：指定一个列为索引，然后将这个列的值作为key，将数据放到哈希表其中的一个bucket中
3、二叉搜索树：指定一个列为索引，然后将这个列的值作为key，来组织一棵二叉搜索树
4、B-Tree：每个节点都是一个页，可以存放多个数据节点，每页中的节点都是有序的；左子树的节点小于当前节点，右子树节点大于当前节点，InnoDB中规定一个页大小为16K
5、B+Tree： 相对于B-Tree，有两个区别
- 非叶子节点只存放索引key，不存放数据，数据只存在叶子节点
- 叶子节点页之间使用链表连接
为什么使用B+树而不是B树？
1、B+Tree的磁盘读写代价更低：由于非叶子节点只存放索引不存放数据，所以每个节点可以存放更多的索引，一次读取查找的关键字更多，树的高度更低
2、B+Tree的查询效率更加稳定，因为只有叶子节点存在数据，所以每次查询的路径长度都是相同的
3、B+Tree更适合范围查询，因为B-Tree的非叶子节点存放数据，所以需要使用中序遍历来查询，而B+Tree只有叶子节点有数据，叶子节点之间使用链表连接，所以只要顺序扫描进行，更加方便
基于上述的原因，B+Tree比B-Tree更适合做数据库索引
mysql同步的方法
1.基于语句的复制 ：主库把sql语句写入到bin log（Binary log）中，完成复制（STATEMENT）–数据量小，可能会主从不一致
2.基于行数据的复制：主库把每一行数据变化的信息作为事件，写入到bin log，完成复制（ROW）–数据量大
3.混合复制：上面两个结合体，默认用语句复制，出问题时候自动切换成行数据复制（MIXED）
mysql 主从同步怎么搞的？如果有一台新机器要加到从机里，怎么个过程。
1、在master端，当发生数据的变化时，将对应的CRUD事件写入到binlog；
2、当slave连接master时，master为slave开启一个binlog dump线程，当master的binlog发生变化时，binlog dump线程会通知slave，并将binlog发送给slave；
3、在slave端，slave创建两个线程：
I/O线程——该线程将master发送的binlog接受并写入本地的relay log；
SQL线程——该线程读取relay log，对salve的数据库进行相应的操作。
完整的 Master & Slave 之间主从复制过程：
增加slave节点过程（重点是寻找binlog的时间点）：
1、在slave机器上配置slave信息，修改mysql.cfg配置并重启slave数据库；
2、查找数据库前一天的备份，将其copy到新增的slave机器上，并导库；
3、定位binlog时间戳；
4、在另外一台slave上查看master.info；
5、在slave 配置slave，进行同步
为什么要MySQL主从结构？
1.实现服务器负载均衡
2.通过复制实现数据的异地备份
3.提高数据库系统的可用性
乐观锁与悲观锁的区别？
乐观锁：认为每次读取都没有更新操作；悲观锁这认为每次读取都有更新操作；
binlog 日志是 master 推的还是 salve 来拉的？
由slave去主动拉取
redis 持久化有哪几种方式，怎么选？
- RDB：在指定的时间间隔能对你的数据进行快照存储。
- AOF：记录每次的操作命令，通过重新执行这些命令来恢复原始的数据。
RDB的启动效率会更高，但是数据的高可用性，即最大限度的避免数据丢失不能保证。AOF会比使用RDB文件大
Redis官方：一般来说， 如果想达保证数据安全性，你应该同时使用两种持久化功能。
如果你非常关心你的数据， 但仍然可以承受数分钟以内的数据丢失， 那么你可以只使用 RDB 持久化。
有很多用户都只使用 AOF 持久化， 但我们并不推荐这种方式： 因为定时生成 RDB 快照（snapshot）非常便于进行数据库备份， 并且 RDB 恢复数据集的速度也要比 AOF 恢复的速度要快， 除此之外， 使用 RDB 还可以避免之前提到的 AOF 程序的 bug 。
redis 主从同步是怎样的过程？
- 从服务器向主服务器发送 SYNC 命令。
- 接到 SYNC 命令的主服务器会调用BGSAVE 命令（fork子进程），创建一个 RDB 文件，并使用缓冲区记录接下来执行的所有写命令。
- 当主服务器执行完 BGSAVE 命令时，它会向从服务器发送 RDB 文件，而从服务器则会接收并载入这个文件。
- 主服务器将缓冲区储存的所有写命令发送给从服务器执行。
redis 的 zset 怎么实现的？
有序集合实现：
ziplist：编码的有序集合使用紧挨在一起的压缩列表节点来保存，第一个节点保存member，第二个保存score。ziplist内的集合元素按score从小到大排序，score较小的排在表头位置。
skiplist：编码的有序集合底层是一个命名为**zset的结构体**，而一个zset结构同时包含一个字典和一个跳跃表。跳跃表按score从小到大保存所有集合元素。而字典则保存着从member到score的映射，这样就可以用O(1)的复杂度来查找member对应的score值。虽然同时使用两种结构，但它们会通过指针来共享相同元素的member和score，因此不会浪费额外的内存。增删改查复杂度O(logN)
redis key 的过期策略
1、定时删除：在设置key的过期时间的同时，为该key创建一个定时器，让定时器在key的过期时间来临时，对key进行删除
2、惰性删除：每次从数据库获取key的时候去检查是否过期，若过期，则删除
3、定期删除：每隔一段时间执行一次删除过期key操作
hashmap 是怎样实现的？
tcp 的握手与挥手
select 和 epoll的区别
select是同步多路IO复用，的时间复杂度O(n)
epoll是同步多路IO复用，时间复杂度O(1)
http与https的区别
| http | https | |
|---|---|---|
| 连接 | 无状态 | 有状态（加密、身份认证） |
| 协议 | TCP | TCP+SSL/TLS（安全验证） |
| 端口 | 80 | 443 |
| 开销 | —— | 需要证书，需要向认证机构缴费 |
| 加密 | 明文 | 共享秘钥加密+公开秘钥加密 |
HTTPS的加密方式及如何加？
1、对称加密：加密和解密用的同一套算法，DES、AES、IDEA等
2、非对称加密：使用两个秘钥，公钥+私钥。公钥对网站密码加密，私钥对数据进行解密。RSA，DSA、DH等
在HTTPS中使用公用秘钥+共享秘钥方式。
HTTPS加密：
IP + TCP + TLS +【HTTP】，其中是对整个http加密。
raft算法和zk选主算法
raft算法：启动时在集群中指定一些机器为candidate（候选人），然后candidate开始向其他机器（尤其是follower（选民））拉票，当某一个candidate的票数超过半数，它就成为leader（同美国总统选举）
ZAB算法：
a、快速leader选举
b、发现或者版本建立
c、同步（follower从leader同步数据和状态）
d、广播（leader广播数据或状态到follower）
以上存在脑裂和羊群效应
Kafka 选主怎么做的？
1、通过ZK选主：最简单最直观的方案是，leader在zk上创建一个临时节点，所有Follower对此节点注册监听，当leader宕机时，此时ISR里的所有Follower都尝试创建该节点，而创建成功者（Zookeeper保证只有一个能创建成功）即是新的Leader，其它Replica即为Follower。
2、Controller方式：它在所有的broker中选出一个controller，所有的partition的leader选举都由controller决定
使用controller的原因：当kafka集群业务很多，partition达到成千上万时，当broker宕机时，造成集群内大量的调整，会造成大量Watch事件被触发，Zookeeper负载会过重。zk是不适合大量写操作的。
controller通过监听Zookeeper间接节点出发，然后controller再跟其他的broker具体的去交互实现的（rpc的方式）。
各种消息队列对比
| 特性 | ActiveMQ | RabbitMQ | Kafka | RocketMQ |
|---|---|---|---|---|
| PRODUCER-COMSUMER | 支持 | 支持 | 支持 | 支持 |
| PUBLISH-SUBSCRIBE | 支持 | 支持 | 支持 | 支持 |
| REQUEST-REPLY | 支持 | 支持 | - | 支持 |
| API完备性 | 高 | 高 | 高 | 低（静态配置） |
| 多语言支持 | 支持，JAVA优先 | 语言无关 | 支持，JAVA优先 | 支持 |
| 单机呑吐量 | 万级 | 万级 | 十万级 | 单机万级 |
| 消息延迟 | - | 微秒级 | 毫秒级 | - |
| 可用性 | 高（主从） | 高（主从） | 非常高（分布式） | 高 |
| 消息丢失 | - | 低 | 理论上不会丢失 | - |
| 消息重复 | - | 可控制 | 理论上会有重复 | - |
| 文档的完备性 | 高 | 高 | 高 | 中 |
| 提供快速入门 | 有 | 有 | 有 | 无 |
| 首次部署难度 | - | 低 | 中 | 高 |
kafka 分区怎么同步的
kafka 怎么保证不丢消息的
生产端：
1、ack的配置策略，ack=all 或 -1；
2、retries的配置策略，重试；
消费端：
1、enable.auto.commit=false
kafka 为什么可以扛住这么高的qps
（1）第一个是在写入数据的时候第一个就是因为kafka是顺序写入数据的，把普通的那种随机IO变成了顺序IO，这样的话写入数据的速度就比较快
（2）第二个就是kafka读取数据的时候是基于sendfile实现Zero Copy
（3）第三个就是kafka的数据压缩，Kafka使用了批量压缩，即将多个消息一起压缩而不是单个消息压缩
下面这个图就是传统的数据读取：
这个是kafka使用的零拷贝的数据读取：
http各种返回码，401和406啥区别？
redis 哨兵和集群
kafka partition broker consumer consumer group topic 等都是啥关系？
两个单向链表，返回求和后的链表结构，例如2->3->1->5，和3->6，结果返回2->3->5->1
二面没什么好说的，和面试聊人生去了，我以为是要凉的节奏，但是却拿到了offer。三面HR 面
5、实习的面经
了解哪些缓存，redis用过吗，跳表原理讲一下，LRU又是怎么实现的
客户端的登录验证过程，如何保存密码
cookie和session的区别
HTTPS中为什么需要第三方证书，客户端为什么信任第三方证书
------------------------
手撕代码：
* 实现一个堆，包括插入和删除元素函数的实现
* 字符串按空格反转（I LOVE SHOPEE => I EVOL EEPOHS）
* 链表按空格反转（I->’ ‘->L->O->V->E->’ ‘->S->H->O->P->E->E => I->’ ‘E->V->O->L->’ 'E->E->P->O->H->S）
6、后端开发
项目 有什么难点
缓存雪崩
jvm 新生代老年代的 GC
Redis 持久化机制
哪些情况线程会被阻塞
Spring 的事务 如果 A 是事务，B 不是事务，A 调用 B，B 发生异常会如何
SQL 注入，SQL 的预编译
数据库隔离级别，幻读
深拷贝浅拷贝
HashMap 底层数据结构，链表长度转化、扩容
算法1：两个栈做一个队列
算法2：数据流找最大的 n 个数
二面 03.19 五点面试 半小时结束
主要是问项目，自己负责的部分，有什么难点，用到了消息队列对吧，是拉消息还是MQ推消息，项目中觉得最难的部分
微服务是什么，好处坏处
Spring Boot 最熟悉部分的讲讲
算法：4321 找比它小的字典序数字，那么是 4312，时间复杂度不能是 O(n2)
7、后端面经
一面：
反转链表
1.哈希表解决冲突办法、查找元素的过程是怎样的（不了解查找过程）
2.2000w个数找前1000个（完全不会这种问题，扯的堆排、快排）
3.已知前序和中序 ，求高度
4.数据库主键和索引的区别（扯到了回表查询）
5.回表查询是什么
6.所有存储引擎都是这样吗？（就是myisam用的非聚集，扯一下两个区别）
7.解释脏读、不可重复读、幻影读，举例子说明（幻影读没说好，还要学一学）
8.隔离级别
9.进程线程区别
10.进程之间的通信方式
11.4次挥手
12.为什么3次握手、4次挥手，就是握手挥手中状态 协议为什么要这么设计
13.tcp可靠原因
14.http状态码 301、302
15.项目多少人，你的职责
16.项目中最大挑战、收获较大的
反问
二面
1.项目
2.udp和tcp的区别
3.流量控制
4.socket通信用的函数说一下
5.四次挥手，状态、数据包
6.介绍存储引擎，优缺点啥的，索引机制
7.B+树索引、哈希索引，优点（还想说B树的，但是被打断了）
8.有没有用过其他的中间件（没有，并不知道中间件是什么）
9.进程使用的状态怎么查看（我说的是windows的任务管理器哈哈哈哈）
10.进程调度算法
8、后端校招
数据库相关问题
- 说一下知道的DB引擎、区别–innodb myisam memory等自由发挥
- 索引以及优化，联合索引问题（这里记不太清了，只记得有索引的问题）
- 说一下MySQL隔离级别–RU RC RR Serializable
- 每种隔离级别解决的问题，以及innodb的幻读解决方案，MVCC
- 说一下几种锁和实现–乐观锁、悲观锁、共享锁、互斥锁、行锁、表锁
redis相关
- 你常用的数据结构、说一下原理
- redis单线程多线程、有什么优劣
- 集群、哨兵、主从
- 持久化方案
- 缓存一致性方案
- redis事务用过吗，是怎么样的？
语言相关
- 介绍一下主要的几种Java容器类，Collection和Map接口
- ArrayList扩容机制、和LinkedList之间的实现区别
- 有哪几种set？HashSet、TreeSet、LinkedHashSet之前的实现区别，如果遍历的话，会是怎么样一个顺序？（第一次没太听懂，再描述了下才发现意思是hash tree和link hash下存储方式的区别）
- Map呢？三种map的实现
- 介绍一下hashtable、hashmap、concurrenthashmap之间的区别
- 说一下synchronize和Lock（不记得是让说区别还是只说前面那个了）
- 多线程几个问题（这里记不太清了）
其他几个
- TCP UDP区别，简述一下三次握手过程
- 让你来做一个直播流软件，从上到下涉及协议栈？
- topk相关问题以及解决
二面
这一面有点迷，面完甚至以为挂了
- 上来一道算法题、大概是升序旋转数组最小值，leetcode 153，给了线性和二分两种思路，然后让手写一下二分。这里有点尴尬，二分最开始写错了下标更新，面试官看了下没让改直接继续了
- ACID
- 数据库索引 B+ Hash B
- HTTP 说一下知道的几种状态码，常用不常用的说了20个左右
- 进程调度算法（少说了个多级反馈队列
- 反问（面到这里才20多分钟，当时还以为算法题写错了个地方面试官对我没兴趣了，自己一度以为是挂了
9、后端java
Java 类加载器说一下
Java内存分为哪几部分
这几个内存部分哪里会出现内存溢出的情况，只说了堆和栈的
Synchronized关键字， 说到有序性的时候突然卡了，不知道怎么解释。。按照自己理解说了下
数据库索引
说到索引，B+树特点
数据库事务的特点
说到隔离性，隔离的四个级别，每个级别的可能问题
说到不可重复读和幻读，讲一下它们的不同
http协议的特点
http状态码
https协议解释
http无状态怎么解决
tcp协议的特点
tcp的可靠性怎么保证
为什么三次握手而不是两次或者四次?
三次握手有什么隐患么？ 讲了洪泛攻击
洪范攻击怎么解决？ 真不知道， 猜了一个ip限制
结束链接，四挥之后客户端处于什么状态， 我讲了timewait.
为什么要有timewait？
如果服务端没有收到第四次挥手信号，服务端是什么状态？ 说了半关闭，问有什么问题么，说了资源浪费…不知道对不对
进程和线程的区别
虚拟内存
进程通信的方式
算法：因为在zoom, 只要说思路就行了。
1.给定一组非负整数，重新排列它们的顺序使之组成一个最大的整数（如给定[3,30,34,5,9]，输出9534330），结果用字符串输出…记得我看过，但是忘了，气死，后来想了一会，用了比较笨的办法
\2. 写一个函数，将输入的字符串中大写字母移动到字符串的末尾，同时需要保留出现的相对顺序, 例如输入AaBbCc 返回 abcABC, 要求不使用额外内存… 想了一会， 用类似冒泡的方法解决
前面知识题应该都比较平和，两道算法题没答好，都是用的比较笨的方法…
3.19 shopee二面，30min左右，面试官也挺随和，我讲什么都会有一个反馈
1. 自我介绍
2. 仔细介绍一下你做的一个项目，掰扯了二十分钟
\3. 问我有什么问题
\4. 问我有什么爱好
\5. 爱好中我说 有了看书， 然后问我看技术类的书么， 我说看， redis实战之类的，然后让我说说redis…
\6. 然后问我redis为什么会很快。。
10、后端社招
一面：
整个过程就是针对简历上的一个项目，进行基础知识的考察，整个过程大概一个小时：
\1. ES的倒排索引
\2. MySQL存储引擎、常用索引类型、红黑树特点等，主从复制
\3. kafka可靠性实现，kafka选举controller机制（集群启动时、controller宕机之后）
\4. Redis 集群、哨兵、复制，持久化的方式
\5. Python内存管理、装饰器、GIL、进程线程协程，进程间通信、线程间通信
\6. Linux常用的命令，Nginx的高可用实现
\7. 其他的一些不记得了，基本上都是从项目中引申出来的知识点，还问了哈希表，知不知道Java中hashmap的实现吗
二面： 面完之后，第二天约的二面，二面大概40分钟：
二面也是问项目，都是项目的一下细节：
就是问了整个项目的整体的流程，为什么选择某些技术或者基础组件
HR面：
二面完的当天下午，HR微信约了第二天的HR面
11、后端
\1. TCP三次握手
\2. TCP/UDP 区别
\3. UDP主要应用
\4. 进程通信方式
\5. 进程、线程、协程
\6. 协程特点，对比线程
\7. HTTPS加密具体细节SSL
\8. Python全局解释器
\9. Python装饰器
\10. Python并发
\11. Python字典为什么O(1)
\12. 算法题，反转字符串
\13. 算法题，字符串中大小写字母分成前后两部分，字母顺序不变
12、后端
2.一上来面试官就对我项目感兴趣，因为项目上线服务器了，而且我自己写了tps的测试数据，就问我怎么来的，有什么因素影响，聊了10多分钟
3.进程线程的通信方式，我这里被问到管道使用场景，毕竟面试官引导我答出来，有关于父子进程方面的，我顺着答出来，面试说答对了
4.同步io和异步io区别
5.异步io.在java中调用什么api，我忘了哭了，然后面试官说没关系，你没用过我理解，我只是想了解一下而已
6.数据库索引，b+树，为什么用他
7.虚拟内存
8反问团队情况，最后征求学习建议，然后说很认可我这次一面，说基本说到点了，思路清晰，让我继续学习深入的进入
我觉得我总结以前的shopee面经，他们很喜欢问操作系统的，牛友们注意一下，可以复习一下
13、
快排时间复杂度，什么是时候是最坏，怎么优化
jvm
垃圾回收
activemq消息队列
b树与b+树
mysql引擎
为什么用主键自增
聚簇索引中，N行形成一个页（一页通常大小为16K)。如果碰到不规则数据插入时，为了保持B+树的平衡，会造成频繁的页分裂和页旋转，插入速度比较慢。所以聚簇索引的主键值应尽量是连续增长的值，而不是随机值(不要用随机字符串或UUID)。
故对于InnoDB的主键，尽量用整型，而且是递增的整型。这样在存储/查询上都是非常高效的。
redo与undo
写题，简单的dfs找路径
还有想不起来了…………
二面：
先写题，找奇点，说思路，O（n）时间复杂度，然后让优化，优化找到O（logn）
然后手写给8分钟，当时太紧张，没写出来，有bug
题没写出来，估计是没戏了
感觉面试官想快点结束面试，就问了几个简单的问题
TCP三次握手，四次挥手
数据库ACID
进程调度算法
就完了，八成是凉凉了，哎，无缘shopee了
14、校招后端
一面
- 数据结构：
- 比较数组和链表
- 什么是平衡二叉树
- 编程：实现反转链表
- 数据库：
- MySQL复合索引
- MySQL引擎MyISAM和InnoDB有什么区别
- 操作系统：
- Linux的Kill命令（-9信号的作用）
- Linux的进程间的通信
- 网络：
- TCP的四次挥手
- TCP四次挥手中的TIME_WAIT状态
- TCP和UDP的优缺点比较
- 算法：
- 编程：快速排序
二面
- 问到了笔试题的第三题：
复习笔试题有必要。 - 问了TCP3次握手的过程，为什么要3次?
- 针对TCP3次握手怎么攻击？ （这个没答出来）
- SYN攻击和DDOS攻击原理
- TCP的传输过程是怎么样的？怎么确保有序？
有点生疏，但还是答出来了7788 - 悲观锁和乐观锁？在项目中有用到吗？
15、后端
Shopee后台开发一面
1.一上来redis
set的使用场景 有序set的使用场景
2.反射 反射的弊端
3.多路IO模型 NIO
4.dubbo
5.进程调度算法
6.进程间怎么通信
7.线程 进程 协程关系
8.为什么要用索引，索引的实现，b+树和b树相比优点
9.hashmap冲突解决，链表遍历效率低下怎么解决
10.说一下事务，事务隔离级别，怎么解决不可重复读
11.jdbc
12.握手为什么是3次，挥手4次
16、校招后端
简述下tcp四次挥手？追问：tcp如何保证传输的有序性，可靠性？
LRU算法是如何实现的？（我说的是哈希表+链表实现，并要把具体实现的思路讲明白）
1000个数据，查找出现次数最多的k个数字（优先队列）
session和cookie区别？追问：session是如何识别用户的？（emm，我说了session id，面试官又追问id存在哪儿）
cpu内存你了解吗？（emm，我把jvm具体说了下，什么栈什么堆）
cpu缓存你知道吗？（我把cache的原理啥的说了一遍，面试官追问cache的缓存如何和外存的缓存保持一致性？我心想：我面得是后端吗？）
数据库最左前缀匹配原则是啥？
数据库引擎说一下（我说了innidb，面试官追问innodb啥啥啥，我又不会了）
B+树和hash哪个适合做索引
聚簇索引说一下
多线程volite关键字什么作用，追问:可见性你怎么理解的？
17、后端
ArrayList 和 LinkedList 区别，使用场景
堆是什么，数据结构，时间复杂度
排序算法有哪些，归并排序时间复杂度，是不是稳定的
Map 有几种，LinkedHashMap 的数据结构，怎么实现的
数据库三大范式 有哪些反范式的设计
join 和 left join、right join 的区别
数据库事务 持久性是什么 隔离级别 幻读是什么
进程和线程的区别
线程间通信（忘了问的是同步还是通信了）
页面置换算法 LRU 和 LFU
TCP 和 UDP
TCP 怎么保证可靠性
拥塞控制是什么
三次握手
HTTP 状态码有哪些
GET POST 区别 他们系统里有些 GET 请求 用了 POST，这样设计是为什么（想不出来）
乐观锁和悲观锁
Redis 分布式锁使用在了什么地方 怎么实现的 除了 Redis 还有什么方式可以实现
18、后端
2.虚拟内存
3.Java gc
4.TCP timewait
5.http 长连接 短连接
6.常用的排序算法
7.dubbo原理
8.MySQL 索引类型
9.Redis数据类型，有序集合实现原理
10.数组中最小的k个数
11.缺页中断
19、补充
1.巨大文件，TOPK排序
2.短链接知道吗？怎么做？