交行2面：什么是內存溢出和內存泄漏？如何解決？
內存溢出和內存泄漏是我們經常聽到的兩種內存管理問題，那么，它們是如何導致的？又該如何解決？這篇文章，我們來聊一聊。
一、內存溢出
內存溢出（OutOfMemoryError）是指程序在運行時嘗試分配內存，但由于沒有足夠的內存可用，Java 虛擬機（JVM）拋出了 OutOfMemoryError 錯誤。常見的內存溢出區域包括堆內存和永久代（在 Java 8 之后被元空間取代）。
1.導致的原因
導致內存溢出主要有以下幾個原因：1. 堆內存溢出：創建大量對象，導致堆內存耗盡。2. 棧內存溢出：遞歸調用過深，導致棧內存耗盡。3. 永久代/元空間溢出：類加載過多，導致永久代/元空間耗盡。
下面我們用三個示例，分別展示了堆內存溢出、棧內存溢出和永久代/元空間溢出的情況：
(1) 堆內存溢出
如下示例代碼，通過不斷向 ArrayList 添加對象來耗盡堆內存。
import java.util.ArrayList;
import java.util.List;
public class HeapMemoryOverflow {
public static void main(String[] args) {
List<Object> list = new ArrayList<>();
while (true) {
list.add(new Object());
}
}
}在運行上述 HeapMemoryOverflow 示例時，可能需要調整 JVM 參數以較小的堆大小運行，例如 -Xmx10m，以更快地觀察到 OutOfMemoryError。
(2) 棧內存溢出
如下示例代碼，通過遞歸調用一個沒有終止條件的方法，導致棧內存溢出。
public class StackMemoryOverflow {
public static void main(String[] args) {
recursiveMethod();
}
public static void recursiveMethod() {
// 沒有終止條件的遞歸調用
recursiveMethod();
}
}運行StackOverflowError代碼，通常會很快發生棧內存溢出，因為默認的棧大小不大。
(3) 永久代/元空間溢出
在 Java 8 之前，永久代溢出可以通過動態生成大量類來模擬，Java 8 之后，永久代被元空間取代，以下是一個使用 CGLIB 動態生成類的示例，可能導致元空間溢出，需要添加 CGLIB 庫依賴。
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class MetaspaceOverflow {
public static void main(String[] args) {
while (true) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(DummyClass.class);
enhancer.setUseCache(false);
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
return proxy.invokeSuper(obj, args);
}
});
enhancer.create();
}
}
static class DummyClass {
}
}運行 MetaspaceOverflow 示例時，可以使用 JVM 參數 -XX:MaxMetaspaceSize=10m 來限制元空間大小，以更快地觀察到溢出。
2.解決方法
在這里，我們只是給了一個大的思路，關于內存溢出的排查工作也是一個很重要的知識點，我們會在后面的文章中去詳細介紹。
- 增加內存：調整 JVM 參數增加堆內存大小，如 -Xmx。
- 優化代碼：減少不必要的對象創建，優化數據結構。
- 檢查遞歸：避免過深的遞歸調用。
- 監控和分析：使用工具如 JVisualVM、JProfiler 分析內存使用情況。
二、內存泄漏
內存泄漏（Memory Leak）是指程序中存在一些對象，它們不再被使用，但由于仍然被引用，垃圾回收器無法回收這些對象。因此，隨著時間的推移，內存泄漏會導致可用內存逐漸減少，最終可能導致內存溢出。
1.導致的原因
導致內存泄漏主要有以下幾個原因：
- 靜態集合類：使用 static 修飾的集合類持有對象引用，因為靜態集合的生命周期和 JVM 一致，所以靜態集合引用的對象不能被釋放。
- 監聽器和回調：注冊的監聽器或回調未被移除。
- 長生命周期對象持有短生命周期對象：長生命周期對象不當持有短生命周期對象的引用。
下面我們用三個示例，分別展示了內存泄漏可能發生的場景：
(1) 靜態集合類導致的內存泄漏
靜態集合類持有對象引用，導致這些對象無法被垃圾回收。
import java.util.ArrayList;
import java.util.List;
public class StaticCollectionLeak {
// 靜態集合持有對象引用
private static List<Object> objectList = new ArrayList<>();
public static void main(String[] args) {
for (int i = 0; i < 10000; i++) {
// 每次創建一個新對象并添加到靜態集合中
objectList.add(new Object());
}
// 即使在這里試圖清理掉一些其他的引用
System.gc(); // 這些對象仍然無法被回收，因為它們被靜態集合引用
}
}(2) 監聽器和回調未被移除
注冊的監聽器或回調未被移除，導致內存泄漏。
import java.util.ArrayList;
import java.util.List;
public class ListenerLeak {
private List<EventListener> listeners = new ArrayList<>();
public void addListener(EventListener listener) {
listeners.add(listener);
}
public void triggerEvent() {
for (EventListener listener : listeners) {
listener.onEvent();
}
}
public static void main(String[] args) {
ListenerLeak leakExample = new ListenerLeak();
// 匿名類創建的監聽器對象
leakExample.addListener(new EventListener() {
@Override
public void onEvent() {
System.out.println("Event triggered");
}
});
// 假設在某個時候不再需要監聽器，但未移除
// listeners.remove(listener); // 應該移除不需要的監聽器
}
}
interface EventListener {
void onEvent();
}(3) 長生命周期對象持有短生命周期對象
長生命周期對象不當持有短生命周期對象的引用，導致短生命周期對象無法被回收。
import java.util.HashMap;
import java.util.Map;
public class LongLifeCycleLeak {
private static Map<String, byte[]> cache = new HashMap<>();
public static void main(String[] args) {
while (true) {
// 短生命周期對象
byte[] data = new byte[1024 * 1024]; // 1MB
// 長生命周期對象持有短生命周期對象的引用
cache.put(String.valueOf(System.nanoTime()), data);
// 需要定期移除不再需要的數據，否則會導致內存泄漏
// cache.clear(); // 應該在適當時機清理緩存
}
}
}2.解決方法
在這里，我們只是給了一個大的思路，關于內存泄漏的排查工作也是一個很重要的知識點，我們會在后面的文章中去詳細介紹。
- 及時釋放引用：確保不再使用的對象引用被清除。
- 使用弱引用：對緩存或非關鍵對象使用 WeakReference。比如 ThreadLocal 的弱引用會導致內存泄漏，因此使用完 ThreadLocal 一定要記得使用 remove 方法來進行清除。
- 正確管理生命周期：特別是監聽器和回調，確保在不需要時移除。
3.示例代碼
下面示例代碼，用于測試內存泄漏。
import java.util.HashMap;
import java.util.Map;
public class MemoryLeakExample {
private static Map<Integer, String> map = new HashMap<>();
public static void main(String[] args) {
for (int i = 0; i < 100000; i++) {
map.put(i, "value" + i);
}
}
}在上面的代碼中，如果 map 是一個長期存在的靜態變量，并且沒有及時清理，則可能導致內存泄漏。
三、對比
關于內存溢出和內存泄漏的比較如下：
- 觸發時機：內存溢出通常在內存耗盡時立即觸發，而內存泄漏可能在一段時間后逐漸顯現。
- 影響范圍：內存溢出會立即影響程序的可用性，而內存泄漏通常是一個逐步積累的問題。
- 檢測難度：內存溢出較容易檢測，而內存泄漏往往需要深入分析和調試。
- 解決復雜度：內存溢出的解決相對簡單，通常通過優化內存使用或增加內存即可。而內存泄漏的解決需要識別并清理不必要的引用，可能涉及更復雜的代碼重構。
四、總結
本文，我們分析了Java的內存溢出和內存泄漏并且應示例展示了它們導致的原因，應該說它們是比較常見的內存管理問題，如果在生產環境出現也是比較頭疼的問題。所以在日常開發中，我們一定要注意自己的代碼風格和代碼質量，盡量避免這些問題的發生。
