收个滴滴Offer：从小伙三面经历，看看需要学点啥？

说在前面

在尼恩的（50+）读者社群中，经常有小伙伴，需要面试大厂。

后续结合一些大厂的面试真题，给大家梳理一下学习路径，看看大家需要学点啥？

这里也一并把题目以及参考答案，收入咱们的《尼恩Java面试宝典》 V56，供后面的小伙伴参考，提升大家的 3高架构、设计、开发水平。

注：本文以 PDF 持续更新，相关尼恩架构笔记、面试题的PDF文件，请从这里获取：码云

一面(45min)

1.自我介绍

2.工作解决过什么技术难题？

除了crud，最好能做一个、两个有高价值的轮子项目，这里可以结合轮子项目，介绍自己遇到的技术难题。

如果找不到好的轮子项目，可以来咨询尼恩。

3.JAVA中常用的集合，有什么区别

在java中集合主要分为：List，Set，Map三种，其中List与Set是继承自Collection，而Map不是。

List与Set的区别：List中的元素有存放顺序，并且可以存放重复元素，检索效率高，插入删除效率低，Set没有存放顺序，而且不可以存放重复元素，后来的元素会把前面重复的元素替换掉，检索效率低，插入删除效率高。（Set存储位置是由它的HashCode码决定的，所以它存储的对象必须有equals()方法，而且Set遍历只能用迭代，因为它没有下标。）

4.string,stringbuff,StringBuilder 他们之间的区别，谁快

String ：不可变的字符序列；底层使用 byte[] 存储。
StringBuffer ：可变的字符序列；线程安全的，效率低；底层使用 byte[] 存储。
StringBuilder ：可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用 byte[] 存储。

效率从高到底依次是：StringBuilder>StringBuffer>String

5.List遍历中删除元素会有什么问题？那应该怎么遍历

遍历删除List中符合条件的元素主要有以下几种方法：

普通for循环
增强for循环 foreach
迭代器iterator
removeIf 和方法引用 (一行代码搞定)

其中使用普通for循环容易造成遗漏元素的问题，
使用增强for循环foreach会报java.util.ConcurrentModificationException并发修改异常。

所以推荐使用迭代器iterator，或者JDK1.8以上使用lambda表达式进行List的遍历删除元素操作。

以下是上述几种方法的具体分析：

普通for循环

/** 
 * 普通for循环遍历删除元素
 */  
List<Student> students = this.getStudents();  
for (int i=0; i<students.size(); i++) {
    
      
    if (students.get(i).getId()%3 == 0) {
    
      
        Student student = students.get(i);  
        students.remove(student);  
    }  
}

由于在循环中删除元素后，list的索引会自动变化，list.size()获取到的list长度也会实时更新，所以会造成漏掉被删除元素后一个索引的元素。

比如循环到第2个元素时你把它删了，接下来去访问第3个元素，实际上访问到的是原来list的第4个元素，因为原来的第3个元素变成了现在的第2个元素。这样就造成了元素的遗漏。

增强for循环 foreach

/**
 * 增强for循环遍历删除元素
 */
List<Student> students = this.getStudents();  
for (Student stu : students) {
    
      
    if (stu.getId() == 2)   
        students.remove(stu);  
}

使用foreach遍历循环删除符合条件的元素，不会出现普通for循环的遗漏元素问题，但是会产生java.util.ConcurrentModificationException并发修改异常的错误。

报ConcurrentModificationException错误的原因：

先来看一下JDK源码中ArrayList的remove源码是怎么实现的：

public boolean remove(Object o) {
    
    
    if (o == null) {
    
    
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
    
    
                fastRemove(index);
                return true;
            }
    } else {
    
    
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
    
    
                fastRemove(index);
                return true;
            }
    }
    return false;
}

一般情况下程序的执行路径会走到else路径下最终调用fastRemove方法：

private void fastRemove(int index) {
    
    
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

在fastRemove方法中，可以看到第2行把modCount变量的值加一，但在ArrayList返回的迭代器会做迭代器内部的修改次数检查：

final void checkForComodification() {
    
    
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

而foreach写法是对实际的Iterable、hasNext、next方法的简写，因为上面的remove(Object)方法修改了modCount的值，所以才会报出并发修改异常。

要避免这种情况的出现则在使用迭代器迭代时（显式或for-each的隐式）不要使用List的remove，改为用Iterator的remove即可。

迭代器iterator

/**
 *  迭代器iterator
 */
List<Student> students = this.getStudents();  
System.out.println(students);  
Iterator<Student> iterator = students.iterator();  
while (iterator .hasNext()) {
    
      
    Student student = iterator .next();  
    if (iterator.getId() % 2 == 0)  
        iterator.remove();
    //这里要使用Iterator的remove方法移除当前对象，
    // 如果使用List的remove方法，则同样会出现ConcurrentModificationException  
}

由上述foreach报错的原因，注意要使用迭代器的remove方法，而不是List的remove方法。

removeIf 和方法引用

在JDK1.8中，Collection以及其子类新加入了removeIf方法，作用是按照一定规则过滤集合中的元素。

方法引用是也是JDK1.8的新特性之一。方法引用通过方法的名字来指向一个方法，使用一对冒号 :: 来完成对方法的调用，可以使语言的构造更紧凑简洁，减少冗余代码。

使用removeIf和方法引用删除List中符合条件的元素：

List<String> urls = this.getUrls();  
 
// 使用方法引用删除urls中值为"null"的元素
urls.removeIf("null"::equals);

作为removeIf的条件，为true时就删除元素。

使用removeIf 和方法引用，可以将原本需要七八行的代码，缩减到一行即可完成，使代码的构造更紧凑简洁，减少冗余代码。

6.jvm运行时数据区介绍

参考尼恩《Java面试宝典》 JVM专题，有好几百页，非常细致

7.java中如何直接访问内存

Java最初被设计为一种安全的受控环境。尽管如此，Java HotSpot还是包含了一个“后门”，提供了一些可以直接操控内存和线程的低层次操作。

这个后门类——sun.misc.Unsafe——被JDK广泛用于自己的包中，如java.nio和java.util.concurrent。

这个类在JDK中有广泛的应用，例如，java.nio和java.util.concurrent、Netty、Caffeine。

但是丝毫不建议随意使用这个后门。因为这个API十分不安全、不轻便、而且不稳定。很难想象在日常开发中使用这些危险的，不可移植和未经校验的API。

然而,Unsafe提供一种简单的方法来观察HotSpot JVM内部的一些技巧。

获取Unsafe

sun.misc.Unsafe这个类的访问是受限的，它的构造方法是私有的，相应的工厂方法要求必须被Bootloader载入才能使用，也就是说，只有JDK内部分才能使用这个工厂方法来构造Unsafe对象。

public final class Unsafe {
    
    

    …

    private Unsafe() {
    
    }

    private static final Unsafe theUnsafe = new Unsafe();
    …
        public static Unsafe getUnsafe() {
    
    
        Class cc = sun.reflect.Reflection.getCallerClass(2);
        if (cc.getClassLoader() != null)
            throw new SecurityException(“Unsafe”);
        return theUnsafe;

    }
    …

}

幸运地是，有一个theUnsafe属性可以被利用来检索Unsafe实例，我们可以见到的写一个反射方法，来获取Unsafe实例：

public static Unsafe getUnsafe() {
    
    
    try {
    
    
        Field f = Unsafe.class.getDeclaredField(“theUnsafe”);
        f.setAccessible(true);
        return (Unsafe)f.get(null);
    } catch (Exception e) {
    
     /* … */ }
}

下面将看看一些Unsafe的方法。

1.对直接内存进行读写。

long getAddress(long address) 和void putAddress(long address, long x)

2.另一个类似的方法对直接内存进行读写，将C语言的结构体和Java对象进行转换。

int getInt(Object o, long offset) , void putInt(Object o, long offset, int x)

3.分配内存，可以看做是C语言的malloc()函数的一种包装

long allocateMemory(long bytes)

具体请去看NIO的源码，尼恩在《高性能葵花宝典》中，有详细的介绍。

sun.misc.Unsafe提供了几乎是不受限制的监控和修改虚拟机运行时数据结构的能力。

尽管这些能力几乎是和Java开发本身不相干的，但是对于想要学习HotSpot虚拟机但是没有C++代码调试，或者需要去创建特别的分析工具的人来说，Unsafe是一个伟大的工具。

8.类加载器，双亲委派机制

参考尼恩《Java面试宝典》 JVM专题，有好几百页，非常细致

9.java线程状态，之间如何转换

参考尼恩《Java面试宝典》多线程专题，那个专题，对线程的状态，做了超乎寻常的介绍，有好几百页，非常细致

10.sleep和wait的区别

sleep 方法和 wait 方法都是用来将线程进入休眠状态的，并且 sleep 和 wait 方法都可以响应 interrupt 中断，也就是线程在休眠的过程中，如果收到中断信号，都可以进行响应并中断，且都可以抛出 InterruptedException 异常，那 sleep 和 wait 有什么区别呢？

区别一：语法使用不同

wait 方法必须配合 synchronized 一起使用，不然在运行时就会抛出 IllegalMonitorStateException 的异常，

而 sleep 可以单独使用，无需配合 synchronized 一起使用。

区别二：所属类不同

wait 方法属于 Object 类的方法，而 sleep 属于 Thread 类的方法，

区别三：唤醒方式不同

sleep 方法必须要传递一个超时时间的参数，且过了超时时间之后，线程会自动唤醒。

而 wait 方法可以不传递任何参数，不传递任何参数时表示永久休眠，直到另一个线程调用了 notify 或 notifyAll 之后，休眠的线程才能被唤醒。

也就是说 sleep 方法具有主动唤醒功能，而不传递任何参数的 wait 方法只能被动的被唤醒。

区别四：释放锁资源不同

wait 方法会主动的释放锁，而 sleep 方法则不会。

11.数据库中有哪些方法何以删除表数据,有什么区别

truncate,delete,drop

truncate、delete、drop区别概述

它们的区别如下表所示：

区别点	drop	truncate	delete
执行速度	快	较快	慢
命令分类	DDL（数据定义语言）	DDL（数据定义语言）	DML（数据操作语言）
删除对象	删除整张表和表结构，以及表的索引、约束和触发器。	只删除表数据，表的结构、索引、约束等会被保留。	只删除表的全部或部分数据，表结构、索引、约束等会被保留。
删除条件(where)	不能用	不能用	可使用
回滚	不可回滚	不可回滚	可回滚
自增初始值	-	重置	不重置

truncate、drop 和 delete 的区别主要有以下 6 点：

执行速度：drop > truncate > detele。
delete 和 truncate 只删除表数据，而 drop 会删除表数据和表结构以及表的索引、约束和触发器。
delete 可以加 where 条件实现部分数据删除，而 truncate 和 drop 不能加 where 条件是整体删除。
truncate 和 drop 是立即执行，且不能恢复；而 delete 会走事务，可以撤回和恢复。
truncate 会重置自增列为 1，而 delete 不会重置自增列。
truncate 和 drop 是 DDL 语句，而 delete 是 DML 语句。

12.为什么delete相对比较慢

简单来说

delete 是逐行执行的，并且在执行时会把操作日志记录下来，以备日后回滚使用，所以 delete 的执行速度是比较慢的；而 truncate 的操作是先复制一个新的表结构，再把原先的表整体删除，所以它的执行速度居中，而 drop 的执行速度最快。

往深入说，为什么delete相对比较慢，原因复杂：

1、查询的表，没有加索引

写了一个查询sql，结果查询的条件字段没有索引，导致需要全表扫描，查找数据，这是大家遇到最多，也是最容易理解的。

这种，一般，在表数据量比较少时，如低于十万级，不会觉得慢，但是，当表中数据量达到或超过十万级时，就会体现出查询时间特别长了。

2、查询的索引，无效

知道索引很重要，所以，一般建表的时候，都会加上一些索引，但是，有了索引，并不代表查询速度就一定会快，因为，还要看能否正确使用索引。

查询条件，没有索引字段
查询条件使用 or，选择式过滤条件，导致索引无效
查询条件使用like，且从头部开始模糊匹配，导致索引无效
查询条件不满足复合索引的最左匹配原则，导致索引无效
查询条件，索引列使用了隐式类型转换，导致索引无效
查询条件，索引列使用了聚合函数，导致索引无效
查询条件，索引列使用了算术运算(+、-、…)，导致索引无效
查询条件，索引列使用了逻辑运算(!=、<>、is null、 is not null …)，导致索引无效
左右关联时，字段类型不一致，导致索引无效

3、查询使用了临时表

临时表可能大家不知道，但是回表查询，大家可能听说过，就是说一次查询不满足，还需要再查一次，查两次才能出结果，这当然就会慢啦。

哪临时表一般都是怎么产生的呢？

通过一次查询返回的数据，要进行下一步的过滤、显示时，发现返回的数据中不满足过滤条件，或者没有显示的字段，又要回头查一次原表，从原表中获取满足条件的数据，这些数据，就放在临时表中。

本来，回头查一次，就已经消耗了时间了，奈何，临时表还有空间大小限制，占用内存空间，还可能空间不够用，存放不下所有数据。所以，一般，只要出现使用了临时表，这个sql的性能都很差。

4、join或子查询，太多

关联查询，在实际工作中，非常场景，关联的表越多，那么，数据过滤筛选就越来复杂，时间自然就会越长了。所以，一般而言，关联表不建议超过3个，而且数据量小的表放左边，大的表放在右边。

5、查询结果数据量，太大了

查询结果数据量太大，常见的有两种，

第1种，就是直查的表数据量太大，如千万级。一张表千万级，即使建了索引，索引文件也会很大，深度也会很深，查询速度，自然就会很慢了。

第2种，就是联表笛卡尔积量太大。对于第一种，优化建议，一般是对表采用分表分区了。而第二种，就简单粗暴的sql拆分优化。

6、锁竞争

现在MySQL的表一般都是InnoDB存储引擎，这种引擎的表是行锁，每次锁定一行。即，如果有一个事务在操作某一行数据，就会锁定这一行的操作行为，其他事务不能操作，直到前一个事务操作完成，commit数据变更之后，后面的事务才能获取操作。这就会出现，一个事务，做变更，没有结束，后面的所有事务操作就得等待，如果此时又有多个事务在排队等待，当前一事务操作结束，等待的事务就会竞争抢锁，这种‘你不仁，我不义’，一旦发生，SQL的性能就会很慢了。

7、limit分页，太深

有些时候，我们需要偏移一定量数据之后，获取某些数据，就很容易想到用limit，但是，如果偏移量很大时，就会发现SQL执行起来非常非常慢了，因为，偏移量会分页读取到buffpool中，数据量大，占用的buffpool空间就会大，而这个空间大小是配置的，一般不会很大，所以，导致了慢sql。对于这个问题的优化，建议写一个过滤条件，再与limit结合实现。

8、配置参数，不合理

我们很多时候使用数据库，都是安装了之后，就直接用，不会对数据库配置参数进行过多了解和设置。比如buff相关的参数这就是数据库中一类非常重要的配置参数，在mysql中，有很多带有 buff、cache、size、length、max、min、limit等字样的配置参数，都是非常重要的配置参数。这些配置参数，是直接关系数据库的性能的。如果，你数据库安装在一个配置很高的机器上，但是，这些配置参数却不知道修改，都用默认值。哪也就只能哀怨“这么高的硬件配置，性能怎么还是这么差？

9、频繁刷脏页

脏页，是内存数据页和磁盘数据页不一致。这个一般发生在数据更新操作中。更新数据，需要先把数据读取出来，然后再内存中更新，然后再生成日志文件，再回放日志文件，实现表数据更新。而当更新数据量大，buffpool写满，或者是后续生成的回放日志文件写满，都会导致这个操作过程变慢。对于这种问题优化，一般建议是少批量修改，多次提交。

10、系统资源，不够用数据库，使用来存储数据的，要频繁进行磁盘操作，所以，一般，我们都会选择磁盘IO性能比较好的机器作为数据库服务器。同时，数据库还要经常进行数据交换，所以，也需要有足够的内存，所以，内存也会相应要求高些。而这些硬件，仅仅只是作为数据库服务器硬件选择的基本要求；数据库也是一个软件，软件也是安装在操作系统中的，所以，也会受操作系统的参数的一些限制，所以，当硬件资源不够用，或者达到了系统参数限制值时，也是会导致操作变慢的。

等等等等，回答到这里，面试官一定是五体投地了。

13.group by需要注意什么

oderby，group by的底层原理和调优，非常重要，内容非常多

请参考尼恩《Java面试宝典》 Mysql专题，有好几百页，非常细致

14.redis数据类型

请参考尼恩《Java面试宝典》 redis专题，有好几百页，非常细致

15.redis单线程为什么快

请参考尼恩《Java面试宝典》 redis专题，有好几百页，非常细致

16.什么是IO多路复用？为什么有IO多路复用机制？

请参考尼恩《java 高并发核心编程卷1 加强版》对IO多路复用加密过程做了抓包分析，非常细致

17.算法：两个数组，找出其中相同的数返回

算法，请参见尼恩社群（50+群）的算法资料

二面（35min）

1.自我介绍

2.TCP,UDP区别

请参考尼恩《Java面试宝典》 tcp、ip专题，有好几百页，非常细致

3.TCP中的连接有什么意义，它是逻辑上的还是物理上的

请参考尼恩《Java面试宝典》 tcp、ip专题，有好几百页，非常细致

4.TCP如何保证可靠性

请参考尼恩《Java面试宝典》 tcp、ip专题，有好几百页，非常细致

5.三次握手，四次挥手，为什么握手是三次，挥手是四次

请参考尼恩《Java面试宝典》 tcp、ip专题，有好几百页，非常细致

6.https加密过程

请参考尼恩《java 高并发核心编程卷1 加强版》对https加密过程做了抓包分析，非常细致

7.cpu在什么情况下会发生指令重排序

指令重排序是编译器处于性能考虑,在不影响程序(单线程程序)正确性的条件下进行重新排序*。*

指令重排序不是必然发生的,指令重排序会导致线程安全问题。

请参考尼恩《java 高并发核心编程卷2加强版》对https加密过程做了抓包分析，非常细致

8.volatile原理，怎样保证可见性

请参考尼恩《java 高并发核心编程卷2加强版》对https加密过程做了抓包分析，非常细致

9.cms中为什么需要重新标记这一步？

实际场景中，很多小伙伴以为CMS 垃圾回收器早就过时了，现在都流行 G1、ZGC 垃圾回收器了！学这个东西一点用都没有！

实际上CMS 垃圾回收器于 JDK1.5 时期推出，在 JDK9 中被废弃，在 JDK14 中被移除。

而用来替换 CMS 垃圾回收器的便是我们常说的 G1 垃圾回收器。但 G1 垃圾回收器也是在 CMS 的基础上进行改进的，因此简单了解下 CMS 垃圾回收器也是有必要的。

CMS（Concurrent Mark Sweep）垃圾回收器是第一个关注 GC 停顿时间的垃圾收集器。 在这之前的垃圾回收器，要么就是串行垃圾回收方式，要么就是关注系统吞吐量。

这样的垃圾回收器对于强交互的程序很不友好，而 CMS 垃圾回收器的出现，则打破了这个尴尬的局面。因此，CMS 垃圾回收器诞生之后就受到了大家的欢迎，导致现在还有非常多的应用还在继续使用它。

对于 CMS 垃圾回收器来说，其实通过「标记 - 清除」算法实现的，它的运行过程分为 4 个步骤，包括：

初始标记
并发标记
重新标记
并发清除

初始标记，指的是寻找所有被 GCRoots 引用的对象，该阶段需要「Stop the World」。 这个步骤仅仅只是标记一下 GC Roots 能直接关联到的对象，并不需要做整个引用的扫描，因此速度很快。

并发标记，指的是对「初始标记阶段」标记的对象进行整个引用链的扫描，该阶段不需要「Stop the World」。 对整个引用链做扫描需要花费非常多的时间，因此通过垃圾回收线程与用户线程并发执行，可以降低垃圾回收的时间，从而降低系统响应时间。这也是 CMS 垃圾回收器能极大降低 GC 停顿时间的核心原因，但这也带来了一些问题，即：并发标记的时候，引用可能发生变化，因此可能发生漏标（本应该回收的垃圾没有被回收）和多标（本不应该回收的垃圾被回收）了。

重新标记，指的是对「并发标记」阶段出现的问题进行校正，该阶段需要「Stop the World」。

为啥需要重新标记呢？

正如并发标记阶段说到的，由于垃圾回收算法和用户线程并发执行，虽然能降低响应时间，但是会发生漏标和多标的问题。所以对于 CMS 回收器来说，它需要这个阶段来做一些校验，解决并发标记阶段发生的问题。

并发清除，指的是将标记为垃圾的对象进行清除，该阶段不需要「Stop the World」。 在这个阶段，垃圾回收线程与用户线程可以并发执行，因此并不影响用户的响应时间。

从上面的描述步骤中我们可以看出：CMS 之所以能极大地降低 GC 停顿时间，本质上是将原本冗长的引用链扫描进行切分。通过 GC 线程与用户线程并发执行，加上重新标记校正的方式，减少了垃圾回收的时间。

10.cms的并发清除阶段，如果之前被标记为垃圾的对象又被重新引用了怎么办？

可达性分析算法，标记死亡的已不可达。不会被引用

11.IO多路复用select,poll,epoll的区别

尼恩在《高性能葵花宝典》中，有详细的介绍。

12.epoll 水平触发（LT）与边缘触发（ET）的区别？

尼恩在《高性能葵花宝典》中，有详细的介绍。

13.算法：自己实现一个平方根函数
14.算法：线程A,B交替打印自然数

算法，请参见 尼恩社群（50+群）的算法资料

三面（30min）

1.自我介绍

2.问项目

除了crud，最好能做一个、两个有高价值的轮子项目，这里可以结合轮子项目，介绍自己遇到的技术难题。

如果找不到好的轮子项目，可以来咨询尼恩。

3.因为项目里面有用到RocketMQ，问了一些mq的东西

请参考尼恩《Java面试宝典》消息队列专题，有好几百页，非常细致

4.类加载过程

请参考尼恩《Java面试宝典》 jvm专题，有好几百页，非常细致

5.类加载器

请参考尼恩《Java面试宝典》 jvm专题，有好几百页，非常细致

6.索引建立原则，什么字段适合建立索引

请参考尼恩《Java面试宝典》 mysql专题，有好几百页，非常细致

7.synchronized和lock有什么区别？什么场景下用lock

请参考尼恩《java 高并发核心编程卷2 加强版》synchronized VS lock 做了详细的介绍，非常细致

8.单例里面用的什么锁，为什么用synchronized，单例解决了什么问题，会有什么问题

请参考尼恩《java 高并发核心编程卷2 加强版》高并发设计模式做了详细的介绍，非常细致

9.如何保证java共享变量的安全

请参考尼恩《java 高并发核心编程卷2 加强版》高并发设计模式做了详细的介绍，非常细致

10.详细介绍五种IO模型，都有什么区别？

请参考尼恩《java 高并发核心编程卷1 加强版》对五大 io模型做了详细的介绍，非常细致

11.为什么需要这些IO模型

请参考尼恩《java 高并发核心编程卷1 加强版》对五大 io模型做了详细的介绍，非常细致

12.redis中主从复制的原理

请参考尼恩《Java面试宝典》 redis 专题，有好几百页，非常细致

说在最后：

在尼恩的（50+）读者社群中，经常有小伙伴，需要面试大厂。

后续结合一些大厂的面试真题，给大家梳理一下学习路径，看看大家需要学点啥？

基本上，把尼恩的《Java 高并发三部曲》吃透，还有《尼恩Java面试宝典》吃透，滴滴offer，已收。

下一期的大厂面经，大家需要分析哪个厂，可以发消息给尼恩。