内存泄漏是一种资源泄漏，当计算机程序错误地管理内存分配，导致不再需要的内存无法释放时，就会发生这种情况=>维基百科定义

这是一种相对基于上下文的主题，你可以根据自己的喜好创建一个主题，只要未使用的引用永远不会被客户使用，但仍然存在。

第一个例子应该是一个自定义堆栈，而不取消有效Java第6项中过时的引用。

当然，只要你愿意，还有很多，但如果我们看看Java内置类，它可能是

子列表（）

让我们检查一些超级愚蠢的代码来产生泄漏。

public class MemoryLeak {
    private static final int HUGE_SIZE = 10_000;

    public static void main(String... args) {
        letsLeakNow();
    }

    private static void letsLeakNow() {
        Map<Integer, Object> leakMap = new HashMap<>();
        for (int i = 0; i < HUGE_SIZE; ++i) {
            leakMap.put(i * 2, getListWithRandomNumber());
        }
    }



    private static List<Integer> getListWithRandomNumber() {
        List<Integer> originalHugeIntList = new ArrayList<>();
        for (int i = 0; i < HUGE_SIZE; ++i) {
            originalHugeIntList.add(new Random().nextInt());
        }
        return originalHugeIntList.subList(0, 1);
    }
}

实际上，还有另一个技巧，我们可以利用HashMap的查找过程，使用HashMap造成内存泄漏。实际上有两种类型：

hashCode（）始终相同，但equals（）不同；使用随机hashCode（）和equals（）始终为true；

Why?

hashCode（）->bucket=>equals（）来定位该对

我打算先提到substring（），然后再提到subList（），但这个问题似乎已经解决了，因为它的源代码在JDK8中。

public String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > value.length) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    int subLen = endIndex - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return ((beginIndex == 0) && (endIndex == value.length)) ? this
            : new String(value, beginIndex, subLen);
}

您可以尝试使用while循环使许多缓冲的读取器尝试同时打开同一个文件，条件决不为false。最上面的樱桃是这些永远不会关闭。

线程在终止之前不会被收集。它们是垃圾收集的根源。它们是少数几个不能简单地通过忘记它们或清除对它们的引用来回收的对象之一。

考虑：终止工作线程的基本模式是设置线程看到的一些条件变量。线程可以定期检查变量，并将其作为终止的信号。如果变量未声明为volatile，那么线程可能看不到对变量的更改，因此它不知道终止。或者想象一下，如果一些线程想要更新共享对象，但在试图锁定该对象时出现死锁。

如果您只有少数线程，这些错误可能会很明显，因为您的程序将停止正常工作。如果您有一个线程池，可以根据需要创建更多线程，那么过时/卡住的线程可能不会被注意到，并且会无限累积，从而导致内存泄漏。线程可能会在应用程序中使用其他数据，因此也会阻止收集它们直接引用的任何数据。

作为玩具示例：

static void leakMe(final Object object) {
    new Thread() {
        public void run() {
            Object o = object;
            for (;;) {
                try {
                    sleep(Long.MAX_VALUE);
                } catch (InterruptedException e) {}
            }
        }
    }.start();
}

可以任意调用System.gc（），但传递给leakMe的对象永远不会死。

我可以从这里复制我的答案：在Java中导致内存泄漏的最简单方法

“在计算机科学中，当计算机程序消耗内存但无法将其释放回操作系统时，就会发生内存泄漏。”（维基百科）

简单的答案是：你不能。Java执行自动内存管理，并将释放您不需要的资源。你无法阻止这种情况的发生。它将始终能够释放资源。在具有手动内存管理的程序中，这是不同的。可以使用malloc（）在C中获得一些内存。要释放内存，您需要malloc返回的指针并对其调用free（）。但是，如果您不再拥有指针（被覆盖或超过生存期），那么很遗憾，您无法释放此内存，因此会出现内存泄漏。

到目前为止，所有其他答案在我的定义中都不是真正的内存泄漏。他们的目标都是快速用毫无意义的东西填满记忆。但在任何时候，您仍然可以取消引用创建的对象，从而释放内存-->无泄漏。尽管我不得不承认，acconrad的答案非常接近，因为他的解决方案实际上是通过强制垃圾收集器进入一个无休止的循环来“崩溃”垃圾收集器）。

长时间的答案是：通过使用JNI为Java编写库，可以获得内存泄漏，JNI可以进行手动内存管理，从而产生内存泄漏。如果调用此库，Java进程将泄漏内存。或者，JVM中可能存在bug，从而导致JVM丢失内存。JVM中可能存在bug，甚至可能存在一些已知的bug，因为垃圾收集并不是那么简单，但它仍然是一个bug。根据设计，这是不可能的。您可能需要一些受此类错误影响的Java代码。很抱歉，我不知道，而且在下一个Java版本中，它可能不再是一个bug。

也许通过JNI使用外部本机代码？

使用纯Java，这几乎是不可能的。

但这是一种“标准”类型的内存泄漏，即您无法再访问内存，但它仍然属于应用程序。相反，您可以保留对未使用对象的引用，或者打开流而不关闭它们。

另一种可能造成巨大内存泄漏的方法是保存对TreeMap的Map.Entry＜K，V＞的引用。

很难理解为什么这只适用于TreeMaps，但通过查看实现，原因可能是：TreeMap.Entry存储了对其同级的引用，因此，如果TreeMaps准备好被收集，但其他类保存了对其Map.Intry的引用，则整个Map将保留在内存中。

现实生活场景：

想象一下，有一个数据库查询返回一个大的TreeMap数据结构。人们通常使用TreeMaps作为元素插入顺序。

public static Map<String, Integer> pseudoQueryDatabase();

如果查询被多次调用，并且对于每个查询（因此，对于返回的每个Map），您在某个地方保存了一个条目，那么内存将不断增长。

考虑以下包装类：

class EntryHolder {
    Map.Entry<String, Integer> entry;

    EntryHolder(Map.Entry<String, Integer> entry) {
        this.entry = entry;
    }
}

应用程序：

public class LeakTest {

    private final List<EntryHolder> holdersCache = new ArrayList<>();
    private static final int MAP_SIZE = 100_000;

    public void run() {
        // create 500 entries each holding a reference to an Entry of a TreeMap
        IntStream.range(0, 500).forEach(value -> {
            // create map
            final Map<String, Integer> map = pseudoQueryDatabase();

            final int index = new Random().nextInt(MAP_SIZE);

            // get random entry from map
            for (Map.Entry<String, Integer> entry : map.entrySet()) {
                if (entry.getValue().equals(index)) {
                    holdersCache.add(new EntryHolder(entry));
                    break;
                }
            }
            // to observe behavior in visualvm
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

    }

    public static Map<String, Integer> pseudoQueryDatabase() {
        final Map<String, Integer> map = new TreeMap<>();
        IntStream.range(0, MAP_SIZE).forEach(i -> map.put(String.valueOf(i), i));
        return map;
    }

    public static void main(String[] args) throws Exception {
        new LeakTest().run();
    }
}

在每次pseudoQueryDatabase（）调用之后，映射实例应该准备好进行收集，但这不会发生，因为至少有一个Entry存储在其他地方。

根据您的jvm设置，应用程序可能会在早期因OutOfMemoryError而崩溃。

您可以从这个可视化虚拟机图中看到内存是如何保持增长的。

哈希数据结构（HashMap）不会发生同样的情况。

这是使用HashMap时的图形。

解决方案？只需直接保存键/值（您可能已经这样做了），而不是保存Map.Entry。

我在这里写了一个更广泛的基准。