目录
- 前言
- 一、讲讲short数据类型，short s1 = 1; s1 = s1+1;对不对？
- 二、使用final关键字的好处
- 三、如果String中重写equals不重写hashCode会出现什么问题？
- 四、ConcurrentHashMap的get方法是不加锁的，如何保证线程安全？
- 五、ConcurrentHashMap扩容的过程中，这时候插入的新节点怎么处理？
- 六、LinkedList适合用什么排序？
- 七、多线程并发，如何做到子线程都执行结束了主线程才继续往下执行？
- 八、实现LRU（Least Recently Used，最近最少使用算法）
- 九、JVM内存中程序计数器的作用是什么？
- 十、Redis：集群中原始的哈希方法有什么缺点？
- 十一、Socket中的函数
- 十二、SQL中HAVING和WHERE的区别
- 十三、HTTP常见状态码
- 十四、Redis中有序集合的底层实现？跳跃表如何实现？Redis中的跳跃表做了哪些优化？
- 十五、死锁产生的条件，如何避免死锁？
- 十六、会写Shell脚本吗？
- 十七、GC Root有哪些？
- 十八、设计题：有英雄、小怪、Boss这些角色，设计战斗模块
- 十九、算法题：有一些任务，有的任务有前驱任务，即完成了前驱任务才能开始当前任务，给出一个合理的处理顺序
- 二十、编程题：在旋转数组中查找最小值的下标，用二分查找优化
- 二十一、Linux进程通信地方式
- 后记
前言
“实战面经”是本专栏的第二个部分，本篇博文是第五篇博文，如有需要，可：
- 点击这里，返回本专栏的索引文章
- 点击这里，返回上一篇《【Java校招面试】实战面经（四）》
一、讲讲short数据类型，short s1 = 1; s1 = s1+1;对不对？
1. short类型长度为16位，数据范围为-32768~32767
2. 不对，这个等式的右值需要强制类型转换为short，s1 + 1的时候将s1代表的1转换成了整型做的，想要避免强制转换，用s1++即可。
二、使用final关键字的好处
1. final关键字提高了性能。JVM会缓存final变量。
2. final变量可以安全得在多线程环境下进行共享，而不需要额外的同步开销。
3. 使用final关键字，JVM会对方法、变量及类进行优化。
三、如果String中重写equals不重写hashCode会出现什么问题？
在HashMap中，通过调用Key的hashCode函数获取哈希值。如果重写了equals不重写hashCode，将String作为Key的时候，HashMap中就有可能存在两个Key相同的键值对，破坏了Key的唯一性。
四、ConcurrentHashMap的get方法是不加锁的，如何保证线程安全？
ConcurrentHashMap的get方法不加锁，是因为Node数组用volatile关键字修饰了，一个线程对被volatile修饰的变量进行的修改对其他线程是立即可见的，所以get方法不需要加锁。
五、ConcurrentHashMap扩容的过程中，这时候插入的新节点怎么处理？
在 ConcurrentHashMap 的扩容过程中插入新节点时，需要遵循以下步骤：
1. 检查并触发扩容: 当插入新节点时，首先要检查当前是否有一个线程正在执行扩容操作。如果没有线程正在扩容并且当前容量达到了扩容阈值，当前线程可以触发扩容操作。
2. 创建新数组和转发节点: 和 HashMap 类似，在触发扩容后，需要创建一个更大的新数组（新数组的大小通常是原数组大小的两倍）。之后，要在原数组的第一个槽位中创建一个特殊的“转发节点”（forwardingNode），它将指向新的数组。当其他线程处理该槽位时，这个转发节点表示当前正在进行扩容操作。
3. 参与扩容操作: 不论当前线程是否触发了扩容操作，只要正在进行扩容操作，线程就会参与到扩容操作中去。这样可以确保在扩容过程中，其他线程也可以分摊一部分扩容负担。
4. 节点迁移: 迁移节点时，线程不是简单地迁移整个槽位，而是将槽位中的元素平分成几个任务，每个线程根据自己的 ID 和任务总数参与迁移特定的部分。这样，在该阶段，多个线程可以同时参与迁移任务。
5. 插入新节点: 扩容完成后，当前线程会将新节点插入到新的 ConcurrentHashMap 中。这个过程与在没有扩容时直接插入新节点的过程类似，但应使用锁机制（synchronized 或者 Lock 类）确保线程安全。
6. 更新属性和节点: 更新相关属性，如容量、阈值等，本次扩容完成后，将新数组替换原数组。
六、LinkedList适合用什么排序？
1. 对于 LinkedList（链表），归并排序（Merge Sort）是一个适合且效率较高的排序算法。归并排序是一种分治算法，原理是不断地将链表分为两个子链表，排序这两个子链表，然后再合并排序好的两个子链表。
2. 原因主要有以下几点:
1) 非随机访问特性: LinkedList 不支持像数组那样的快速随机访问，获取链表中的任意元素需要顺序遍历。归并排序是一种基于顺序访问的算法，因此与链表的特性相符。
2) 稳定性: 归并排序是一种稳定的排序算法，这意味着具有相同值的元素在排序后保持原有的相对顺序。
3) 原地排序: LinkedList 的归并排序可以实现在原地进行，不需要额外的空间复杂度（除了递归调用栈，在非递归实现中没有这些开销，总得来说LinedList的归并排序总体空间复杂度为 O(logn)）
3. 需要注意的是: 对于简单的问题（如较小的链表），插入排序可能更合适，因为插入排序也是顺序访问，而且具有更低的常数时间开销。对于复杂问题（如大型链表），归并排序通常效果更好。
七、多线程并发，如何做到子线程都执行结束了主线程才继续往下执行？
1. 对每个子线程调用Thread.join()函数；
2. 使用CountDownLatch，将初始值设为子线程的数量，主线程调用CountDownLatch的wait()函数等待。每个子线程执行结束就countDown，直到计数为0，即每个线程都执行完毕，则主线程继续执行。
3. FutureTask和Callable组合，需要写个死循环用FutureTask轮询线程的状态。
八、实现LRU（Least Recently Used，最近最少使用算法）
LinkedHashMap是基于哈希表和双向链表的一个数据结构，它可以按照插入顺序或访问顺序保存元素。因此，通过调整 LinkedHashMap 的配置，我们可以实现 LRU（最近最少使用）算法。
import java.util.LinkedHashMap;
import java.util.Map;
public class LRUCache<K, V> extends LinkedHashMap<K, V> {
private final int cacheSize;
public LRUCache(int cacheSize) {
super(16, 0.75f, true);
this.cacheSize = cacheSize;
}
@Override
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
return size() > cacheSize;
}
public static void main(String[] args) {
LRUCache<Integer, String> cache = new LRUCache<>(3);
cache.put(1, "A");
cache.put(2, "B");
cache.put(3, "C");
// 访问元素 1
cache.get(1);
// 添加元素 4，将会导致元素 2 被移除，因为它是最近最少使用的
cache.put(4, "D");
// 打印缓存内容：{3=C, 1=A, 4=D}
System.out.println(cache);
}
}
代码说明:
- 在这个实现中，我们创建了一个名为 LRUCache 的类，继承自 LinkedHashMap。LRUCache 的构造函数接收一个参数 cacheSize，用于设置缓存中允许的元素最大数量。super(16, 0.75f, true) 表示 LinkedHashMap 的初始容量为 16，加载因子为 0.75，使用访问顺序保存元素。
- 要实现 LRU 算法，我们需要覆盖 removeEldestEntry 方法，它返回一个布尔值，以确定是否应移除最老的条目。
- 在 main 函数中，我们创建一个包含3个元素的 LRUCache。当我们访问元素 1 后，再添加元素 4 时，最近最少使用的元素 2 将被移除。
- 在上述示例中，我们实现了一个基于 LRU 策略的键值存储。该存储在达到最大容量时，会自动将最近最少使用的键值对移除。
九、JVM内存中程序计数器的作用是什么？
程序计数器用来记录线程当前正在执行的字节码的行号。
十、Redis：集群中原始的哈希方法有什么缺点？
增删节点的时候需要对全部的数据重新进行哈希计算（比如原来有5个节点，数据对5取余，去掉一个节点后节点数量变为4，全部数据都要重新对4取余），计算量和数据转移的成本比较大。
十一、Socket中的函数
1. 服务端: 建立socket，声明自身的端口号和地址并绑定到socket，使用listen打开监听，然后不断用accept去查看是否有连接，如果有，捕获socket，并通过recv获取消息的内容，通信完成后调用closeSocket关闭这个对应accept到的socket，如果不再需要等待任何客户端连接，那么用closeSocket关闭掉自身的socket。
1) socket: 加载套接字库，创建套接字文件描述符。
2) bind: 绑定套接字到一个IP地址和一个端口上。
3) listen: 将套接字设置为监听模式等待连接请求。
4) accept: 阻塞等待新的连接，捕获新连接的socket。
5) send/recv: 用返回的套接字和客户端进行通信。
6) closesocket: 关闭套接字，关闭加载的套接字库。
2. 客户端: 建立socket，通过端口号和地址确定目标服务器，使用Connect连接到服务器，send发送消息，等待处理，通信完成后调用closeSocket关闭socket。
1) socket: 加载套接字库，创建套接字。
2) connect: 向服务器发出连接请求。
3) send/recv: 和服务器进行通信
4) closesocket: 关闭套接字，关闭加载的套接字库。
十二、SQL中HAVING和WHERE的区别
1. WHERE用于过滤行，HAVING用于过滤分组。
2. WHERE用于在表中做过滤，HAVING对查询结果做过滤，如果HAVING过滤的字段没有跟在SELECT后面，会报错“未知的列”。
十三、HTTP常见状态码
- 1xx: 指示信息，表示请求已接收，继续处理
- 2xx: 成功，表示请求已被成功接收、理解、接受
- 200, OK: 正常返回信息
- 3xx: 重定向，要完成请求必须进行更进一步的操作
- 301, 永久重定向: 请求的资源永久分配了新的url，以后应使用新url
- 302, 临时重定向: 请求的资源临时分配了新的url
- 4xx: 客户端错误，请求有语法错误或请求无法实现
- 400, Bad Request: 客户端请求有语法错误，不能被服务器理解
- 401, Unauthorized: 请求未经授权，这个状态码必须和WWW-Authenticate报头域一起使用
- 403, Forbidden: 服务器收到请求，但是拒绝提供服务
- 404, Not Found: 请求资源不存在
- 5xx: 服务器错误，服务器未能实现合法的请求
- 500, Internal Server Error: 服务器发生了不可预期的错误
- 503, Server Unavailable: 服务器当前不能处理客户端的请求，一段时间后可能恢复正常
十四、Redis中有序集合的底层实现？跳跃表如何实现？Redis中的跳跃表做了哪些优化？
Redis中的有序集合底层通过跳跃表实现
见《实战面经（四）》第二十五题
十五、死锁产生的条件，如何避免死锁？
1. 死锁产生的条件: 互斥、占有且等待、循环等待、非抢占
2. 避免死锁的方法:
1) 针对占有且等待: 设置锁的优先级，按照一定顺序加锁；
2) 针对循环等待: 设定超时时间，超时就放弃自己所持有的锁；
3) 针对非抢占: 系统检测到死锁后，强制一个线程释放掉它持有的锁。
十六、会写Shell脚本吗？
会写比较简单的，比如我们的语料库预处理时间比较长，希望执行完之后发个邮件通知。
用mailutils发邮件
echo “邮件正文” | mail -s 邮件主题 收件地址
十七、GC Root有哪些？
1. 活跃的线程
2. 虚拟机栈中的变量引用的对象
3. 本地方法栈中的变量引用的对象
4. 方法区中的静态变量和常量引用的对象。
十八、设计题：有英雄、小怪、Boss这些角色，设计战斗模块
分为公平战斗（你打我一下，我再打你一下）和即时战斗两种场景
1. 公共的角色类: 需要一个抽象的超类用于抽象出英雄、小怪、Boss等角色的共性，这些角色都是这个超类的子类。
2. 公共的战斗数据工具类: 用于计算攻击、防御、伤害值等数据的工具类
3. 公平战斗: 战斗类，实例化对象时需要传入对战的双方，然后按规则进行对战，直到一方生命值 <= 0.
4. 即时战斗: A攻击B就是A调用B的“掉血”方法，具体的伤害值需要调用战斗数据工具类来计算。
5. 渲染: 前端根据后台的数据变化按照设定的帧率刷新UI。
十九、算法题：有一些任务，有的任务有前驱任务，即完成了前驱任务才能开始当前任务，给出一个合理的处理顺序
为解决这个问题，可以使用拓扑排序（Topological Sorting）算法。拓扑排序通常应用于具有部分顺序的任务列表。
import java.util.*;
public class TopologicalSorting {
private int vertices;
private LinkedList<Integer> adjacencyList[];
@SuppressWarnings("unchecked")
public TopologicalSorting(int vertices) {
this.vertices = vertices;
adjacencyList = new LinkedList[vertices];
for (int i = 0; i < vertices; i++) {
adjacencyList[i] = new LinkedList<>();
}
}
public void addEdge(int source, int dest) {
adjacencyList[source].add(dest);
}
public void topologicalSorting() {
boolean[] visited = new boolean[vertices];
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < vertices; i++) {
if (!visited[i]) {
DFS(i, visited, stack);
}
}
while (!stack.empty()) {
System.out.print(stack.pop() + " ");
}
}
private void DFS(int vertex, boolean[] visited, Stack<Integer> stack) {
visited[vertex] = true;
for (Integer neighbor : adjacencyList[vertex]) {
if (!visited[neighbor]) {
DFS(neighbor, visited, stack);
}
}
stack.push(vertex);
}
public static void main(String[] args) {
TopologicalSorting graph = new TopologicalSorting(6);
graph.addEdge(5, 2);
graph.addEdge(5, 0);
graph.addEdge(4, 0);
graph.addEdge(4, 1);
graph.addEdge(2, 3);
graph.addEdge(3, 1);
System.out.println("Topological Sorting Order:");
graph.topologicalSorting();
}
}
算法说明：
- 在这个示例中，我们创建了一个名为 TopologicalSorting 的类。TopologicalSorting 类中包含图的顶点数量和邻接列表。addEdge 方法用于向图中添加边。
- topologicalSorting 方法是实现拓扑排序的主要方法。该方法首先对每个顶点执行深度优先遍历（DFS），并将遍历结束时的顶点压入栈中。遍历所有顶点后，弹出栈中的所有元素，即为拓扑排序后的顺序。
- 在 main 函数中，我们创建了一个包含 6 个节点（0 到 5）的有向图，并通过 addEdge 方法添加了任务之间的依赖关系。然后调用 topologicalSorting 方法获取任务处理顺序。当程序运行时，它将输出拓扑排序的顺序，确保在执行任务时遵循依赖关系。
- 需要注意的是: 拓扑排序仅在有向无环图（DAG）中有效。在有环的依赖关系中，任务之间会存在死锁。
二十、编程题：在旋转数组中查找最小值的下标，用二分查找优化
public int findMin(int[] nums) {
if (nums.length == 1)
return nums[0];
int left = 0, right = nums.length - 1;
if (nums[right] > nums[0])
return nums[0];
while (right >= left) {
int mid = left + (right - left) / 2;
if (nums[mid] > nums[mid + 1])
return nums[mid + 1];
if (nums[mid - 1] > nums[mid])
return nums[mid];
if (nums[mid] > nums[0])
left = mid + 1;
else
right = mid - 1;
}
return -1;
}
注: 由于存在索引超界的可能，先排除掉数组长度为1的情况，然后注意right的初值等于length – 1.
二十一、Linux进程通信地方式
1. 共享内存
2. 管道
3. 套接字
4. 信号量（Windows没有）
5. 信号（Windows没有）
6. 消息队列（Windows没有）
后记
这份面经中对编程写代码的考察比较多，体型也很经典。
