企业官网建设流程全解析

1. 面试高频题解析：从基础到进阶的完整指南

在技术面试的战场上，每个求职者都渴望拥有一份全面而深入的备考指南。作为经历过数十场技术面试的老兵，我深知面试官最常考察的核心知识点和解题思路。这份指南不同于市面上泛泛而谈的面试题集，而是基于真实面试场景和CSDN社区高频讨论，提炼出的最具代表性的问题集合。

技术面试的本质是考察候选人的三个核心能力：基础知识的扎实程度、问题分析的系统性，以及代码实现的严谨性。面试官往往会通过层层递进的问题，观察你如何拆解复杂问题、如何处理边界条件，以及如何优化解决方案。因此，单纯背诵答案远远不够，必须真正理解每个问题背后的原理和思考逻辑。

本指南涵盖数据结构与算法、数据库、计算机网络、操作系统、编程语言和系统设计六大核心模块，这些都是技术面试中占比超过90%的内容。每个问题都配有详细的解题思路、多种实现方案、复杂度分析以及实际编码示例，确保你能从多个维度掌握知识点。

2. 数据结构与算法精要

2.1 链表操作实战

链表作为最基础的数据结构之一，在面试中出现频率极高。面试官常通过链表问题考察候选人对指针操作和递归思想的理解深度。

2.1.1 反转链表的艺术

反转链表看似简单，却能区分出候选人的编码水平。让我们深入探讨几种实现方式及其适用场景：

迭代法是最直观的解决方案，关键在于维护三个指针：

• prev：指向已反转部分的头节点
• curr：当前待反转节点
• next：保存下一个待处理节点

public ListNode reverseList(ListNode head) { ListNode prev = null; ListNode curr = head; while (curr != null) { ListNode nextTemp = curr.next; // 必须先保存下一个节点 curr.next = prev; // 反转指针方向 prev = curr; // 移动prev指针 curr = nextTemp; // 移动curr指针 } return prev; // 新头节点 }

注意事项：在修改curr.next前必须保存原next节点，否则会丢失链表后续部分。循环终止条件是curr为null，此时prev指向新头节点。

递归法展现了更优雅的实现，其核心思想是：

1. 假设head节点之后的链表已经反转
2. 将head节点接在已反转链表的末尾
3. 处理边界条件（空链表或单节点链表）

def reverseList(head): if not head or not head.next: return head p = reverseList(head.next) head.next.next = head # 反转指针方向 head.next = None # 断开原连接 return p

复杂度分析：

• 时间复杂度：O(n)，两种方式都需要遍历整个链表
• 空间复杂度：迭代法O(1)，递归法O(n)（栈空间）

常见误区：

1. 忘记处理空链表的情况
2. 在迭代法中丢失next节点引用
3. 递归法中没有正确设置head.next为null导致循环链表

2.1.2 环形链表检测的巧妙解法

检测链表是否有环是另一个经典问题，快慢指针法（Floyd判圈算法）是最优解：

def hasCycle(head): slow = fast = head while fast and fast.next: # 快指针需要两步，所以要检查fast.next slow = slow.next fast = fast.next.next if slow == fast: # 相遇说明有环 return True return False

算法原理：快指针每次走两步，慢指针每次走一步。如果有环，快指针最终会追上慢指针（类似于跑道上的套圈）；如果无环，快指针会先到达链表尾部。

进阶问题：如何找到环的入口节点？这需要一点数学推导：

1. 设链表头到环入口距离为a，环入口到相遇点距离为b，相遇点到环入口距离为c
2. 相遇时，慢指针走了a+b，快指针走了a+b+n(b+c)
3. 根据快指针速度是慢指针两倍：2(a+b) = a+b+n(b+c) => a = (n-1)(b+c)+c
4. 这意味着从链表头和相遇点同时出发，最终会在环入口相遇

实现代码：

public ListNode detectCycle(ListNode head) { ListNode slow = head, fast = head; while (fast != null && fast.next != null) { slow = slow.next; fast = fast.next.next; if (slow == fast) { ListNode ptr = head; while (ptr != slow) { ptr = ptr.next; slow = slow.next; } return ptr; } } return null; }

2.2 树与二叉树的深度解析

树结构在算法面试中占比很大，尤其是二叉树的各种遍历和性质判断问题。

2.2.1 二叉树的层序遍历实践

层序遍历（广度优先搜索）需要借助队列实现，关键点是记录每层的节点数量：

vector<vector<int>> levelOrder(TreeNode* root) { vector<vector<int>> result; if (!root) return result; queue<TreeNode*> q; q.push(root); while (!q.empty()) { int levelSize = q.size(); vector<int> currentLevel; for (int i = 0; i < levelSize; ++i) { TreeNode* node = q.front(); q.pop(); currentLevel.push_back(node->val); if (node->left) q.push(node->left); if (node->right) q.push(node->right); } result.push_back(currentLevel); } return result; }

变种问题：

1. 锯齿形层序遍历（奇数层从左到右，偶数层从右到左）
2. 获取每层的最大值/平均值
3. 从底层向上层序遍历（只需反转最终结果）

2.2.2 验证二叉搜索树的陷阱

验证BST看似简单，但很多候选人会掉入陷阱。常见错误方法是只检查当前节点与左右子节点的关系，这无法保证整个子树满足BST性质。

正确做法是传递上下界进行递归验证：

public boolean isValidBST(TreeNode root) { return validate(root, Long.MIN_VALUE, Long.MAX_VALUE); } private boolean validate(TreeNode node, long min, long max) { if (node == null) return true; if (node.val <= min || node.val >= max) return false; return validate(node.left, min, node.val) && validate(node.right, node.val, max); }

使用Long类型是为了处理Integer边界值的情况。时间复杂度O(n)，空间复杂度O(h)（h为树高）

中序遍历解法：BST的中序遍历结果应该是严格递增的，可以利用这一性质：

def isValidBST(root): stack = [] prev = None while stack or root: while root: stack.append(root) root = root.left root = stack.pop() if prev and root.val <= prev.val: return False prev = root root = root.right return True

2.3 排序算法深度剖析

排序算法是计算机科学的基石，理解各种排序算法的优劣对写出高效代码至关重要。

2.3.1 快速排序的优化之道

快速排序的核心是分治思想，但实现细节直接影响性能：

def quicksort(arr, low, high): if low < high: pi = partition(arr, low, high) quicksort(arr, low, pi - 1) quicksort(arr, pi + 1, high) def partition(arr, low, high): pivot = arr[high] # 选择最后一个元素作为基准 i = low - 1 # 小于pivot的区域边界 for j in range(low, high): if arr[j] <= pivot: i += 1 arr[i], arr[j] = arr[j], arr[i] arr[i+1], arr[high] = arr[high], arr[i+1] return i + 1

优化策略：

1. 随机选择基准：避免最坏情况（已排序数组），将pivot = arr[high]改为随机选择
2. 三数取中法：选择首、中、尾三个元素的中值作为基准
3. 小数组切换为插入排序：当子数组长度小于某个阈值（如10）时使用插入排序
4. 三向切分：处理大量重复元素的情况

复杂度分析：

• 平均时间复杂度：O(nlogn)
• 最坏时间复杂度：O(n²)（当分区极度不平衡时）
• 空间复杂度：O(logn)（递归栈空间）

2.3.2 归并排序的稳定之美

归并排序是分治法的经典应用，特别适合链表排序和外排序：

void mergeSort(vector<int>& arr, int l, int r) { if (l < r) { int m = l + (r - l) / 2; // 防止溢出 mergeSort(arr, l, m); mergeSort(arr, m + 1, r); merge(arr, l, m, r); } } void merge(vector<int>& arr, int l, int m, int r) { vector<int> L(arr.begin() + l, arr.begin() + m + 1); vector<int> R(arr.begin() + m + 1, arr.begin() + r + 1); int i = 0, j = 0, k = l; while (i < L.size() && j < R.size()) { if (L[i] <= R[j]) { arr[k++] = L[i++]; } else { arr[k++] = R[j++]; } } while (i < L.size()) arr[k++] = L[i++]; while (j < R.size()) arr[k++] = R[j++]; }

归并排序特点：

1. 稳定排序（相等元素的相对位置不变）
2. 时间复杂度始终为O(nlogn)
3. 需要O(n)额外空间
4. 适合链表排序（不需要随机访问）
5. 是外部排序的基础（处理大数据集）

2.4 动态规划的思维框架

动态规划是算法面试中最具挑战性也最能区分候选人水平的部分。

2.4.1 爬楼梯问题的本质

爬楼梯问题是理解DP的绝佳起点，其递归关系为f(n) = f(n-1) + f(n-2)：

def climbStairs(n): if n <= 2: return n a, b = 1, 2 for _ in range(3, n+1): a, b = b, a + b return b

扩展问题：

1. 如果每次可以爬1、2或3个台阶，解法如何修改？
2. 如果某些台阶被标记为不能踩（给定一个障碍数组），如何解决？
3. 空间复杂度能否优化到O(1)？

2.4.2 最长递增子序列的优化

LIS问题有多种解法，从O(n²)的DP到O(nlogn)的贪心+二分：

public int lengthOfLIS(int[] nums) { int[] tails = new int[nums.length]; int size = 0; for (int x : nums) { int i = 0, j = size; while (i < j) { int m = (i + j) / 2; if (tails[m] < x) { i = m + 1; } else { j = m; } } tails[i] = x; if (i == size) size++; } return size; }

算法原理：

1. tails数组维护长度为i+1的所有递增子序列的最小末尾值
2. 对于每个元素x，通过二分查找找到它在tails中的位置
3. 如果x比所有tails元素大，则扩展最长子序列
4. 否则更新对应的tails值，为未来更长的子序列创造条件

实际应用：这个算法不仅用于求解LIS长度，还可以用于求解俄罗斯套娃信封问题等变种。

3. 数据库核心知识点

3.1 SQL查询的进阶技巧

3.1.1 第二高薪水的多种解法

获取第二高的薪水需要考虑重复值和NULL情况：

-- 方法1：使用DISTINCT和LIMIT SELECT IFNULL( (SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT 1 OFFSET 1), NULL) AS SecondHighestSalary; -- 方法2：使用MAX函数嵌套 SELECT MAX(Salary) AS SecondHighestSalary FROM Employee WHERE Salary < (SELECT MAX(Salary) FROM Employee);

性能考量：

1. 第一种方法在Salary有索引时效率更高
2. 第二种方法需要两次全表扫描
3. 对于大数据集，考虑使用窗口函数：

SELECT DISTINCT Salary AS SecondHighestSalary FROM ( SELECT Salary, DENSE_RANK() OVER (ORDER BY Salary DESC) AS rnk FROM Employee ) t WHERE rnk = 2;

3.1.2 连续出现数字的识别

找出至少连续出现三次的数字有多种实现方式：

-- 自连接方法（直观但性能较差） SELECT DISTINCT l1.Num AS ConsecutiveNums FROM Logs l1, Logs l2, Logs l3 WHERE l1.Id = l2.Id - 1 AND l2.Id = l3.Id - 1 AND l1.Num = l2.Num AND l2.Num = l3.Num; -- 窗口函数方法（MySQL 8.0+） SELECT DISTINCT Num AS ConsecutiveNums FROM ( SELECT Num, LEAD(Num, 1) OVER (ORDER BY Id) AS next1, LEAD(Num, 2) OVER (ORDER BY Id) AS next2 FROM Logs ) t WHERE Num = next1 AND Num = next2;

优化建议：

1. 对于大数据集，窗口函数方法效率更高
2. 如果Id不连续，可以使用ROW_NUMBER()创建连续序号
3. 考虑添加适当的索引提高查询性能

3.2 索引与查询优化

3.2.1 索引失效的常见场景

即使创建了索引，某些查询方式仍会导致索引失效：

1. 使用函数或表达式：

   -- 索引失效 SELECT * FROM users WHERE YEAR(create_time) = 2020; -- 优化为 SELECT * FROM users WHERE create_time >= '2020-01-01' AND create_time < '2021-01-01';

2. 隐式类型转换：

   -- 假设phone是varchar类型 SELECT * FROM users WHERE phone = 13800138000; -- 索引失效 SELECT * FROM users WHERE phone = '13800138000'; -- 使用索引

3. 前导通配符：

   SELECT * FROM products WHERE name LIKE '%apple%'; -- 无法使用索引 SELECT * FROM products WHERE name LIKE 'apple%'; -- 可以使用索引

4. OR条件：

   -- 如果age或name中有一个没有索引，整个查询可能无法使用索引 SELECT * FROM users WHERE age > 18 OR name = 'John';

5. 不等于(!=或<>)和NOT IN：

   SELECT * FROM orders WHERE status != 'completed'; -- 可能无法使用索引

3.2.2 聚集索引与非聚集索引的区别

理解这两种索引的区别对数据库设计至关重要：

设计建议：

1. 选择聚集索引键时要谨慎（最好是自增、唯一、不被更新的列）
2. 避免使用过长的列作为聚集索引键（如varchar(255)）
3. 合理设计非聚集索引包含列以减少回表操作
4. 监控索引使用情况，删除冗余索引

3.3 事务与并发控制

3.3.1 事务隔离级别详解

不同隔离级别解决的问题和带来的问题：

MySQL的特别之处：

• 默认隔离级别是可重复读
• 通过MVCC(多版本并发控制)和间隙锁的组合，实际上在可重复读级别也避免了幻读
• 可以通过SELECT ... FOR UPDATE显式加锁

3.3.2 死锁分析与预防

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

1. 互斥条件
2. 请求与保持
3. 不剥夺条件
4. 循环等待

预防策略：

1. 按固定顺序获取锁（如总是先锁表A再锁表B）
2. 使用超时机制（innodb_lock_wait_timeout）
3. 减少事务持有锁的时间
4. 使用乐观锁替代悲观锁

死锁检测：

-- 查看InnoDB状态，包含最近的死锁信息 SHOW ENGINE INNODB STATUS;

案例分析： 事务1：

BEGIN; UPDATE accounts SET balance = balance - 100 WHERE id = 1; UPDATE accounts SET balance = balance + 100 WHERE id = 2; COMMIT;

事务2：

BEGIN; UPDATE accounts SET balance = balance - 200 WHERE id = 2; UPDATE accounts SET balance = balance + 200 WHERE id = 1; COMMIT;

这两个事务如果并发执行就可能产生死锁。解决方案是统一按照id从小到大顺序更新账户。

4. 计算机网络核心概念

4.1 TCP协议深度解析

4.1.1 三次握手与四次挥手的本质

TCP连接的建立和释放过程蕴含着丰富的设计思想：

三次握手过程：

1. 客户端发送SYN=1, seq=x（客户端进入SYN_SENT状态）
2. 服务端回复SYN=1, ACK=1, seq=y, ack=x+1（服务端进入SYN_RCVD状态）
3. 客户端发送ACK=1, seq=x+1, ack=y+1（双方进入ESTABLISHED状态）

为什么需要三次握手？主要是为了防止已失效的连接请求突然到达服务端，导致资源浪费。两次握手无法解决这个问题。

四次挥手过程：

1. 主动方发送FIN=1, seq=u（进入FIN_WAIT_1状态）
2. 被动方回复ACK=1, ack=u+1（进入CLOSE_WAIT状态）
3. 被动方发送FIN=1, seq=v（进入LAST_ACK状态）
4. 主动方回复ACK=1, ack=v+1（进入TIME_WAIT状态）

TIME_WAIT状态持续2MSL（最长报文段寿命）的原因：

1. 确保最后一个ACK能到达对方
2. 让网络中所有该连接的报文都失效，避免影响新连接

4.1.2 TCP拥塞控制算法

TCP拥塞控制是互联网稳定的关键，包含四个核心算法：

1. 慢启动：

   • 初始cwnd=1 MSS（最大报文段大小）
   • 每收到一个ACK，cwnd增加1 MSS
   • 呈指数增长，直到达到ssthresh（慢启动阈值）

2. 拥塞避免：

   • cwnd超过ssthresh后，每个RTT增加1 MSS
   • 线性增长，更加谨慎

3. 快重传：

   • 当收到3个重复ACK时，立即重传丢失的报文段
   • 不必等待超时计时器

4. 快恢复：

   • 将ssthresh设为当前cwnd的一半
   • cwnd = ssthresh + 3 MSS（因为有3个报文已离开网络）
   • 进入拥塞避免阶段

现代TCP变种：

• TCP Reno：标准实现
• TCP Cubic：Linux默认算法，更适合高速网络
• BBR：Google提出的基于带宽和RTT的算法

4.2 HTTP/HTTPS协议详解

4.2.1 HTTP状态码的语义

HTTP状态码分为五类，正确理解其语义对API设计至关重要：

1. 1xx（信息性）：

   • 100 Continue：客户端应继续发送请求体
   • 101 Switching Protocols：协议切换（如升级到WebSocket）

2. 2xx（成功）：

   • 200 OK：标准成功响应
   • 201 Created：资源创建成功
   • 204 No Content：成功但无返回体

3. 3xx（重定向）：

   • 301 Moved Permanently：永久重定向
   • 302 Found：临时重定向
   • 304 Not Modified：资源未修改（缓存相关）

4. 4xx（客户端错误）：

   • 400 Bad Request：请求语法错误
   • 401 Unauthorized：需要认证
   • 403 Forbidden：认证成功但无权限
   • 404 Not Found：资源不存在

5. 5xx（服务器错误）：

   • 500 Internal Server Error：通用服务器错误
   • 502 Bad Gateway：网关/代理从上游服务器收到无效响应
   • 503 Service Unavailable：服务暂时不可用

RESTful API设计建议：

• 创建成功返回201
• 删除成功返回204
• 条件请求（If-Modified-Since等）返回304
• 参数错误返回400
• 认证失败返回401
• 权限不足返回403

4.2.2 HTTPS安全机制剖析

HTTPS = HTTP + TLS/SSL，安全握手过程如下：

1. ClientHello：

   • 客户端支持的TLS版本
   • 加密套件列表
   • 随机数A

2. ServerHello：

   • 选择的TLS版本和加密套件
   • 服务器证书（包含公钥）
   • 随机数B

3. 证书验证：

   • 客户端验证证书链（是否由可信CA签发，是否过期，域名是否匹配等）
   • 验证证书吊销状态（CRL或OCSP）

4. 密钥交换：

   • 客户端生成预主密钥，用服务器公钥加密后发送
   • 双方通过随机数A、B和预主密钥生成会话密钥

5. 加密通信：

   • 客户端发送ChangeCipherSpec，表示后续通信加密
   • 双方使用对称加密算法进行安全通信

性能优化：

1. 启用TLS 1.3（减少握手轮次）
2. 使用ECDHE密钥交换（支持前向保密）
3. 配置OCSP Stapling（减少证书状态查询延迟）
4. 启用HTTP/2（多路复用提升性能）

4.3 DNS解析全流程

DNS解析是互联网的基础服务，其过程远比表面看起来复杂：

1. 浏览器缓存：首先检查浏览器自身的DNS缓存
2. 系统缓存：查询hosts文件和操作系统DNS缓存（如Windows的DNS Client服务）
3. 路由器缓存：检查本地路由器的DNS缓存
4. ISP DNS服务器：向互联网服务提供商（ISP）的递归DNS服务器查询
5. 根域名服务器：全球共13组根服务器，返回顶级域（如.com）的NS记录
6. 顶级域名服务器：返回权威域名服务器的地址
7. 权威域名服务器：最终返回域名对应的IP地址

DNS记录类型：

• A：IPv4地址
• AAAA：IPv6地址
• CNAME：别名记录
• MX：邮件服务器
• NS：域名服务器
• TXT：文本信息（常用于验证等）

DNS优化策略：

1. 减少DNS查询次数（合并域名）
2. 使用DNS预取（<link rel="dns-prefetch">）
3. 设置合理的TTL值
4. 使用HTTPDNS（绕过传统DNS的问题）

5. 操作系统核心原理

5.1 进程与线程模型

5.1.1 进程间通信方式比较

不同进程间通信(IPC)方式有各自的适用场景：

代码示例（共享内存）：

// 创建共享内存段 int shm_id = shmget(IPC_PRIVATE, size, IPC_CREAT | 0666); // 附加到进程地址空间 char *shm_ptr = shmat(shm_id, NULL, 0); // 使用共享内存 strcpy(shm_ptr, "Hello, shared memory!"); // 分离共享内存 shmdt(shm_ptr); // 删除共享内存段 shmctl(shm_id, IPC_RMID, NULL);

5.1.2 死锁预防与恢复策略

死锁处理的系统化方法：

1. 预防（破坏四个必要条件之一）：

   • 破坏互斥：某些资源可以共享（如只读文件）
   • 破坏请求与保持：一次性申请所有资源（可能降低资源利用率）
   • 破坏不剥夺：允许抢占资源（实现复杂）
   • 破坏循环等待：定义资源线性顺序，按顺序申请

2. 避免（运行时检查）：

   • 银行家算法：检查资源分配后系统是否处于安全状态
   • 需要预先知道进程的最大资源需求

3. 检测与恢复：

   • 定期运行检测算法（如基于资源分配图的算法）
   • 恢复方法：
     • 进程终止：终止所有或部分死锁进程
     • 资源抢占：选择牺牲者进程，回滚并抢占其资源

4. 忽略：

   • 如Unix系统通常不处理死锁，认为应用程序应自行避免
   • 适用于死锁极少发生且影响不大的场景

实际应用建议：

1. 使用锁层次结构（定义锁的获取顺序）
2. 设置锁超时（如tryLock）
3. 避免在持有一个锁时调用可能阻塞的方法
4. 使用工具检测潜在死锁（如Java的Thread Dump分析）

5.2 内存管理机制

5.2.1 虚拟内存与页面置换

虚拟内存系统的关键组成部分：

1. 地址转换：

   • 通过页表将虚拟地址映射到物理地址
   • 多级页表节省空间（如x86的4级页表）
   • TLB(Translation Lookaside Buffer)加速转换

2. 页面置换算法：

   • OPT：理论最优，无法实现
   • FIFO：简单但可能有Belady异常
   • LRU：效果好但实现成本高
   • Clock：近似LRU，使用访问位

3. 工作集模型：

   • 进程在一段时间内访问的页面集合
   • 操作系统跟踪工作集，确保内存足够容纳工作集

代码示例（模拟Clock算法）：

class Clock: def __init__(self, capacity): self.capacity = capacity self.pages = [] self.hand = 0 self.access_bits = {} def access(self, page): if page in self.access_bits: self.access_bits[page] = 1 # 标记为最近使用 return True if len(self.pages) < self.capacity: self.pages.append(page) self.access_bits[page] = 1 else: while True: current = self.pages[self.hand] if self.access_bits[current] == 0: # 替换该页 del self.access_bits[current] self.pages[self.hand] = page self.access_bits[page] = 1 self.hand = (self.hand + 1) % self.capacity break else: self.access_bits[current] = 0 self.hand = (self.hand + 1) % self.capacity return False

5.2.2 内存分配策略比较

不同内存分配策略的对比：

实际应用：

1. Linux内核使用slab分配器管理内核对象
2. glibc的malloc使用多种策略组合（如小内存用slab，大内存用mmap）
3. Java的G1垃圾收集器采用类似伙伴系统的region划分

5.3 文件系统实现

5.3.1 文件存储策略对比

不同文件系统采用不同的存储策略：

现代文件系统特性：

1. 日志功能（journaling）：确保崩溃一致性
2. 写时复制（COW）：如Btrfs，ZFS
3. 快照功能
4. 数据去重
5. 透明压缩

5.3.2 文件描述符与inode

理解文件描述符和inode的关系对系统编程至关重要：

1. inode：

   • 文件系统的元数据结构
   • 包含文件属性（权限、大小、时间戳等）和数据块指针
   • 不包含文件名（文件名在目录项中）

2. 文件描述符：

   • 进程级别的文件访问句柄
   • 本质是进程文件描述符表的索引
   • 每个描述符指向一个文件表项

3. 文件表：

   • 系统级的打开文件表
   • 包含文件状态标志、当前偏移量和指向inode的指针
   • 多个描述符可以指向同一个文件表项（如fork后的子进程）

关系图：

进程A文件描述符表 [0] -> 文件表A -> inode X [1] -> 文件表B -> inode Y 进程B文件描述符表 [0] -> 文件表B -> inode Y [1] -> 文件表C -> inode X

编程注意事项：

1. 文件描述符是进程资源，不会跨进程继承（除非特别安排）
2. dup/dup2创建的新描述符共享同一个文件表项
3. fork后的子进程继承父进程的描述符表副本
4. 不同进程打开同一个文件会创建不同的文件表项

6. 编程语言深度解析

6.1 Java核心机制

6.1.1 JVM内存模型详解

Java虚拟机内存区域划分：

1. 程序计数器：

   • 线程私有
   • 记录当前线程执行的字节码行号
   • 唯一不会发生OOM的区域

2. 虚拟机栈：

   • 线程私有
   • 存储栈帧（局部变量表、操作数栈、动态链接、方法出口）
   • StackOverflowError（栈深度超过限制）
   • OutOfMemoryError（扩展时无法申请足够内存）

3. 本地方法栈：

   • 为Native方法服务
   • 同样可能抛出StackOverflowError和OutOfMemoryError

4. 堆：

   • 所有线程共享
   • 存储对象实例
   • 主要垃圾收集区域
   • 可分为新生代（Eden、Survivor）、老年代

5. 方法区：

   • 存储类信息、常量、静态变量等
   • JDK8之前称为永久代