百度一面，破防了
前文
题目来源：https://www.nowcoder.com/feed/main/detail/d39aabc0debd4dba810b4b9671d54348
本期是【捞捞面经】系列文章的第 2 期，持续更新中.....。
《捞捞面经》系列正式开始连载啦，据说看了这个系列的朋友都拿到了大厂offer~
- 你是否看面经只有问题没有解析？是否缺乏实时一线大厂面经攻略？捞捞面经帮你解决~
- 欢迎星标+订阅，持续更新中。。。致力打造校招核心面试攻略~
- 往期直达：
- 得物一面，场景题问得有点多！
捞捞面经
注：养成先看真题，自己模拟回答，再看解析参考（别忘随手一键三连哦~）
1.基础题
- 有几种网络io模型？
- 异步网络模型在什么场景下你了解有应用过？（回答了线程相关的场景）
- 除了用线程完成，还有什么操作可以完成异步操作？
- 同步阻塞和同步非阻塞在Java层面怎么实现？（说前面网络io模型答得挺顺畅，具体实现细节还需要提升一下）
- 描述一下一次完整的 Http 请求
- 知道的长连接有几种实现方式？
- 一个 Http 请求包含哪几部分内容？
2.代码题
- 设计一个 HashSet（完全不会）
3.场景题
- 1T 的数据怎么加载到 200M 的内存中，并且找到两行一样的数据？
- Java 打开 1T 文件，第一部操作做什么？
- 用代码打开一个文件和用鼠标打开一个文件有什么区别？
注意：博主基础题即不过多介绍，只选经典题目分析。
你了解哪些网络 IO 模型？
常见的网络IO模型有以下几种：
- 阻塞式IO模型（Blocking IO Model）：在这种模型中，当一个线程执行一个 IO 操作时，它会一直阻塞，直到 IO 操作完成。
- 非阻塞式IO模型（Non-Blocking IO Model）：在这种模型中，当一个线程执行一个IO操作时，它不会一直阻塞，而是会立即返回，告诉调用者 IO 操作是否完成。
- 多路复用IO模型（Multiplexed IO Model）：一个线程可以同时监视多个 IO 操作，当有一个 IO 操作完成时，它会通知线程进行处理。
- 信号驱动式IO模型（Signal Driven IO Model）：在这种模型中，当一个 IO 操作完成时，操作系统会向应用程序发送一个信号，应用程序在接收到信号后进行处理。
- 异步IO模型（Asynchronous IO Model）：应用程序发起一个 IO 操作后，不需要等待操作完成，而是可以继续执行其他操作，当 IO 操作完成后，操作系统会通知应用程序进行处理。
异步网络模型你在什么场景下使用过，具体可以应用到哪些地方？
- 高并发的Web应用程序：在Web应用程序中，异步网络模型可以提高服务器的并发处理能力，减少线程的阻塞等待时间，提高系统的吞吐量。
- 高性能的网络服务器：在网络服务器中，异步网络模型可以提高服务器的并发处理能力，减少线程的阻塞等待时间，提高系统的吞吐量。
- 大规模的实时数据处理系统：在实时数据处理系统中，异步网络模型可以提高数据的处理效率，减少数据处理的延迟时间，提高系统的实时性。
- 大规模的分布式系统：在分布式系统中，异步网络模型可以提高系统的并发处理能力，减少线程的阻塞等待时间，提高系统的吞吐量。
异步网络模型可以应用于任何需要高并发、高性能、高实时性的场景，以提高系统的性能和可扩展性，提高用户体验。
能结合具体业务场景举个例吗？
异步网络模型在社交和购物等场景下也非常常见。比如：
- 社交应用程序：在社交应用程序中，异步网络模型可以用于处理用户的聊天消息、动态更新等请求，提高系统的实时性和性能。
- 购物网站：在购物网站中，异步网络模型可以用于处理用户的订单、支付、物流等请求，提高系统的并发处理能力和性能。
举个具体实际的例子，常常玩的 王者荣耀。（个人看法）它需要处理大量的游戏玩家请求，包括登录、注册、查询游戏数据、游戏操作等。如果使用阻塞式IO模型，每个请求都需要创建一个线程来处理，当并发请求量较大时，线程的创建和销毁会带来很大的开销，导致服务器的性能和吞吐量下降。
而如果使用异步网络模型，可以通过 事件驱动的方式处理请求，当有玩家请求到达时，服务器不需要创建新的线程，而是通 过异步IO操作来处理请求，当IO操作完成后，服务器会回调相应的处理函数进行处理，这样可以大大减少线程的创建和销毁开销，提高服务器的性能和吞吐量。
另外，异步网络模型还可以应用于实时数据处理系统，比如金融交易系统、在线广告系统等，这些系统需要实时处理大量的数据请求，如果使用阻塞式IO模型，会导致数据处理的延迟时间较长，影响系统的实时性。而使用异步网络模型，可以通过事件驱动的方式实时处理数据请求，提高系统的实时性和性能。
怎样可以完成异步操作？
- 回调函数：在 Java 中，可以使用回调函数的方式来完成异步操作，比如使用 Java 的回调接口或者
Lambda表达式来实现异步回调。 - Future对象：
Future对象是 Java 中的一种异步编程解决方案，它可以将异步操作封装成一个 Future 对象，然后使用 Future.get() 方法来等待异步操作的完成，从而实现异步操作的同步化编程。 - CompletableFuture对象：
CompletableFuture是Java 8中新增的异步编程解决方案，它可以将异步操作封装成一个 CompletableFuture 对象，然后使用 CompletableFuture的方法来处理异步操作的结果，比如 thenApply()、thenAccept()、thenRun()等方法。 - 异步框架：可以采用一些异步框架可以用于实现异步操作，比如Netty、Vert.x等框架，它们可以通过事件驱动的方式实现异步操作，提高系统的性能和可扩展性。
在Java中，同步阻塞和同步非阻塞可以通过不同的IO模型来实现？
在Java中，同步阻塞和同步非阻塞可以通过不同的 IO 模型来实现。
- 同步阻塞 IO 模型：在Java中，同步阻塞 IO 模型是最常见的 IO 模型，它使用 InputStream 和 OutputStream 等阻塞式 IO 类来实现数据的读写操作。在同步阻塞 IO 模型中，当一个线程调用阻塞式 IO 类的 read() 或 write() 方法时，该线程会被阻塞，直到IO操作完成或者出现异常。
- 同步非阻塞 IO 模型：在Java中，同步非阻塞 IO 模型可以通过使用Java NIO（New IO）来实现。Java NIO 提供了一种基于通道和缓冲区的IO模型，可以实现非阻塞式的IO操作。在同步非阻塞 IO 模型中，当一个线程调用 Java NIO 的通道的 read() 或 write() 方法时，该线程不会被阻塞，而是立即返回，然后可以通过轮询的方式来检查 IO 操作的状态，从而实现非阻塞式的 IO 操作。
能结合具体场景讲解吗？
当涉及到高并发、高性能、高可靠性的场景时，选择合适的 IO 模型非常重要。下面结合具体场景来讲解：
- Web服务器：对于 Web 服务器来说，同步阻塞 IO 模型是最常用的IO模型，因为它可以提供稳定的性能和可靠性。在Java中，可以使用Servlet API来实现同步阻塞 IO 模型。如果需要更高的性能和可扩展性，可以考虑使用异步 IO 模型，比如 Java NIO 或者 Netty 等框架。
- 游戏服务器：对于游戏服务器来说，需要处理
大量的并发连接和实时数据交互，因此同步非阻塞 IO 模型是比较适合的选择。在Java中，可以使用Java NIO或者Netty等框架来实现同步非阻塞IO模型。 - 数据库访问：对于数据库访问来说，同步阻塞IO模型是最常用的IO模型，因为它可以提供稳定的性能和可靠性。在 Java中，可以使用JDBC API 来实现同步阻塞 IO 模型。如果需要更高的性能和可扩展性，可以考虑使用异步 IO 模型，比如使用异步数据库驱动程序，比如 HikariCP 等。
除了同步阻塞和同步非阻塞 IO 模型之外，还有一些其他的 IO 模型，比如异步IO模型、多路复用IO模型等。在实际应用中，应该根据具体的场景和需求来选择合适的 IO 模型。
描述一下一次完整的 Http 请求？
一次完整的HTTP请求通常包括以下步骤：(如果是从浏览器发起地址请求，还需要地址各种解析哦～)
- 建立 TCP 连接：客户端通过
TCP协议与服务器建立连接，进行 “三次握手”。客户端发送 SYN 包，服务器回应 SYN+ACK 包，客户端再回应 ACK 包，完成连接建立。 - 发送 HTTP 请求：客户端向服务器发送 HTTP 请求，请求中包含请求行、请求头和请求体。请求行包括请求方法、请求URL和HTTP协议版本；请求头包括一些附加信息，比如请求头部字段、Cookie 等；请求体包含请求的数据，比如POST请求中的表单数据。
- 服务器处理请求：服务器接收到客户端发送的 HTTP 请求后，会根据请求的内容进行处理，比如查询数据库、读取文件等。
- 服务器返回 HTTP 响应：服务器处理完请求后，会向客户端返回 HTTP 响应，响应中包含响应行、响应头和响应体。响应行包括 HTTP 协议版本、状态码和状态描述；响应头包括一些附加信息，比如响应头部字段、Cookie 等；响应体包含响应的数据，比如 HTML 页面、JSON 数据等。
- 关闭TCP连接：客户端接收到服务器返回的HTTP响应后，会关闭TCP连接，进行 “
四次挥手”。客户端发送 FIN 包，服务器回应 ACK 包，然后服务器发送 FIN 包，客户端回应ACK 包，完成连接关闭。
总之，一次完整的 HTTP 请求包括建立 TCP 连接、发送 HTTP 请求、服务器处理请求、服务器返回 HTTP 响应和关闭 TCP 连接等步骤。在实际应用中，还需要考虑 HTTP 缓存、Cookie、会话管理等问题。
长连接有哪些实现方式？
- 长连接是指客户端和服务器之间保持连接状态，可以在一定时间内进行多次请求和响应，而不必每次请求都重新建立连接。
- 长连接可以减少连接建立和断开的开销，提高网络传输效率，常用于实时通信、推送服务等场景。
常见的长连接实现方式包括：
- HTTP长连接：
HTTP/1.1协议支持长连接，客户端和服务器之间可以保持连接状态，可以在一定时间内进行多次请求和响应。在 HTTP 长连接中，客户端发送请求后，服务器会保持连接状态，直到客户端发送关闭连接的请求或者超时时间到达。 - WebSocket：
WebSocket是一种基于 HTTP 协议的长连接技术，它可以在客户端和服务器之间建立双向通信的连接，实现实时通信和推送服务。WebSocket 协议通过 HTTP协议的升级实现，客户端和服务器之间可以发送和接收数据帧，而不必重新建立连接。 - TCP长连接：
TCP协议支持长连接，客户端和服务器之间可以保持连接状态，可以在一定时间内进行多次请求和响应。在TCP长连接中，客户端和服务器之间建立连接后，可以保持连接状态，直到客户端或服务器发送关闭连接的请求或者网络异常断开连接。
长连接可以提高网络传输效率，常用于实时通信、推送服务等场景
设计一个Hashset？
我随便设计的一个简单的 Hashset（仅供参考）：
- 定义一个哈希表数组，数组的长度为质数，每个元素是一个链表，用于存储哈希冲突的元素。
- 定义一个哈希函数，将元素映射到哈希表数组中的一个位置。可以使用取模运算或者位运算等方式实现哈希函数。
- 实现添加元素的方法。首先根据哈希函数计算元素的哈希值，然后将元素添加到对应位置的链表中。如果链表中已经存在相同的元素，则不添加。
- 实现删除元素的方法。首先根据哈希函数计算元素的哈希值，然后在对应位置的链表中查找元素，如果找到则删除。
- 实现查找元素的方法。首先根据哈希函数计算元素的哈希值，然后在对应位置的链表中查找元素，如果找到则返回元素，否则返回null。
- 实现获取元素个数的方法。遍历哈希表数组，统计所有链表中元素的个数。
- 实现清空哈希表的方法。遍历哈希表数组，将所有链表清空。
下面是一个简单的Java代码实现：
public class MyHashSet<T> {
private static final int DEFAULT_CAPACITY = 16;
private static final float DEFAULT_LOAD_FACTOR = 0.75f;
private Node<T>[] table;
private int size;
private int threshold;
private float loadFactor;
public MyHashSet() {
this(DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR);
}
public MyHashSet(int initialCapacity, float loadFactor) {
table = new Node[initialCapacity];
this.loadFactor = loadFactor;
threshold = (int) (initialCapacity * loadFactor);
}
public boolean add(T value) {
int hash = hash(value);
int index = indexFor(hash, table.length);
Node<T> node = table[index];
while (node != null) {
if (node.value.equals(value)) {
return false;
}
node = node.next;
}
Node<T> newNode = new Node<>(value, table[index]);
table[index] = newNode;
size++;
if (size > threshold) {
resize(table.length * 2);
}
return true;
}
public boolean remove(T value) {
int hash = hash(value);
int index = indexFor(hash, table.length);
Node<T> node = table[index];
Node<T> prev = null;
while (node != null) {
if (node.value.equals(value)) {
if (prev == null) {
table[index] = node.next;
} else {
prev.next = node.next;
}
size--;
return true;
}
prev = node;
node = node.next;
}
return false;
}
public boolean contains(T value) {
int hash = hash(value);
int index = indexFor(hash, table.length);
Node<T> node = table[index];
while (node != null) {
if (node.value.equals(value)) {
return true;
}
node = node.next;
}
return false;
}
public int size() {
return size;
}
public void clear() {
Arrays.fill(table, null);
size = 0;
}
private int hash(T value) {
return value.hashCode();
}
private int indexFor(int hash, int length) {
return hash & (length - 1);
}
private void resize(int newCapacity) {
Node<T>[] newTable = new Node[newCapacity];
for (Node<T> node : table) {
while (node != null) {
Node<T> next = node.next;
int index = indexFor(hash(node.value), newCapacity);
node.next = newTable[index];
newTable[index] = node;
node = next;
}
}
table = newTable;
threshold = (int) (newCapacity * loadFactor);
}
private static class Node<T> {
T value;
Node<T> next;
public Node(T value, Node<T> next) {
this.value = value;
this.next = next;
}
}
}
1T 的数据怎么加载到 200M 的内存中，并找到两行一样的数据？
将 1T 的数据加载到 200M 的内存中是不可能的，因为1T 的数据远远超过了 200M 的内存大小。因此，需要采用一些特殊的算法和技术来解决这个问题。
一种解决方案是使用 外部排序算法，将1T的数据分成多个小文件，每个小文件可以加载到内存中进行排序。然后，使用归并排序的思想将这些小文件合并成一个大文件，并在合并的过程中找到两行一样的数据。
具体步骤如下（参考）：
- 将 1T 的数据分成多个小文件，每个小文件的大小为 200M
- 对每个小文件进行排序，可以使用快速排序等算法。
- 将排序后的小文件合并成一个大文件，可以使用归并排序的思想。
- 在合并的过程中，记录前一个文件的最后一行和当前文件的第一行，比较这两行是否相同，如果相同则找到了两行一样的数据。
- 最后，将找到的两行一样的数据输出即可。
而在实际操作中，还需要考虑磁盘读写速度、文件的读写方式等因素，以提高算法的效率和准确性。
Java打开 1T 的文件，第一步做什么？
在 Java 中打开 1T 的文件，第一步应该是确定文件的读取方式和读取范围。
- 确定文件的读取方式：根据文件的类型和大小，选择适当的文件读取方式。如果文件是文本文件，可以使用 BufferedReader 逐行读取；如果文件是二进制文件，可以使用DataInputStream 或者 FileChannel 进行读取。
- 确定文件的读取范围：由于1T的文件非常大，无法一次性读取到内存中，因此需要确定读取的范围。可以将文件分成多个块，每次读取一个块的数据，处理完后再读取下一个块的数据。可以根据文件的大小和内存的大小来确定块的大小。
用代码打开一个文件和用鼠标打开用什么区别吗？
其底层区别主要在于操作系统和文件系统的交互方式。
用鼠标打开文件是通过操作系统提供的图形用户界面(GUI)来实现的，用户点击图标，但实际操作系统会根据用户的操作来调用相应的API，从而实现文件的打开、读取、写入等操作。而这些 API 实际通常是操作系统提供的底层文件系统接口，例如 Windows 的 Win32 API、Linux 的 POSIX API 等。
而用代码打开文件则是 通过编程语言提供的文件操作API 来实现的，这些API通常是对操作系统底层文件系统接口的封装和抽象。通常可以使用 File、FileInputStream、FileOutputStream 等类来实现文件的打开、读取、写入等操作，这些类会调用底层的操作系统文件系统接口来实现相应的功能。
因此，从底层的角度来看，用代码打开文件和用鼠标打开文件的区别在于调用的API不同，但底层的文件系统接口是相同的。
一次 Http 请求包含哪几部分内容？
- 请求行（Request Line）：包含请求方法、请求的URL和HTTP协议版本。常见的请求方法有
GET、POST、PUT、DELETE等。 - 请求头部（Request Headers）：包含请求的各种头部信息，例如
User-Agent、Content-Type、Cookie等。头部信息提供了关于请求的附加信息，用于服务器处理请求。 - 请求体（Request Body）：对于
GET请求，请求体通常为空。对于 POST 请求等需要传递数据的请求，请求体包含了要发送给服务器的数据。
投递阿里国际数字商业集团等公司10个岗位