我在Java中看到的大多数内存泄漏都与进程不同步有关。

进程A通过TCP与B对话，并告诉进程B创建一些东西。B向资源发出一个ID，比如432423，A将其存储在一个对象中，并在与B对话时使用。在某些情况下，A中的对象会被垃圾收集回收（可能是由于错误），但A从不告诉B这一点（可能是另一个错误）。

现在A不再拥有它在B的RAM中创建的对象的ID，B也不知道A不再引用该对象。实际上，对象是泄漏的。

面试官可能一直在寻找一个循环参考解决方案：

    public static void main(String[] args) {
        while (true) {
            Element first = new Element();
            first.next = new Element();
            first.next.next = first;
        }
    }

这是引用计数垃圾收集器的典型问题。然后，您可以礼貌地解释JVM使用了一种更复杂的算法，它没有这种限制。

这里有一个在纯Java中创建真正的内存泄漏（运行代码无法访问但仍存储在内存中的对象）的好方法：

应用程序创建一个长时间运行的线程（或者使用线程池更快地泄漏）。线程通过（可选的自定义）ClassLoader加载类。该类分配一大块内存（例如新字节[10000000]），在静态字段中存储对它的强引用，然后在ThreadLocal中存储对自身的引用。分配额外的内存是可选的（泄漏类实例就足够了），但这会使泄漏工作得更快。应用程序清除对自定义类或从中加载该类的ClassLoader的所有引用。重复

由于ThreadLocal在Oracle的JDK中的实现方式，这会造成内存泄漏：

每个线程都有一个私有字段threadLocals，它实际上存储线程本地值。此映射中的每个键都是对ThreadLocal对象的弱引用，因此在ThreadLocal对象被垃圾收集后，其条目将从映射中删除。但每个值都是一个强引用，因此当一个值（直接或间接）指向作为其键的ThreadLocal对象时，只要线程存在，该对象既不会被垃圾收集，也不会从映射中删除。

在本例中，强引用链如下所示：

线程对象→ threadLocals映射→ 示例类的实例→ 示例类→ 静态ThreadLocal字段→ ThreadLocal对象。

（ClassLoader在创建泄漏时并没有真正发挥作用，它只是因为这个额外的引用链而使泄漏变得更糟：example类→ 类加载器→ 它加载的所有类。在许多JVM实现中，尤其是在Java7之前，情况更糟，因为类和ClassLoader被直接分配到permagen中，根本不会被垃圾收集。）

这种模式的一个变体是，如果您经常重新部署碰巧使用ThreadLocal的应用程序，而这些应用程序在某种程度上指向自己，那么应用程序容器（如Tomcat）会像筛子一样泄漏内存。这种情况可能有许多微妙的原因，并且通常很难调试和/或修复。

更新：由于很多人一直在要求它，这里有一些示例代码显示了这种行为。

这里有一个非常简单的Java程序，它将耗尽空间

public class OutOfMemory {

    public static void main(String[] arg) {

        List<Long> mem = new LinkedList<Long>();
        while (true) {
            mem.add(new Long(Long.MAX_VALUE));
        }
    }
}

我最近遇到了一种更微妙的资源泄漏。我们通过类加载器的getResourceAsStream打开资源，但碰巧输入流句柄没有关闭。

嗯，你可能会说，真是个白痴。

嗯，有趣的是：通过这种方式，您可以泄漏底层进程的堆内存，而不是JVM的堆内存。

您只需要一个jar文件，其中包含一个将从Java代码中引用的文件。jar文件越大，分配内存的速度越快。

您可以使用以下类轻松创建这样的jar：

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class BigJarCreator {
    public static void main(String[] args) throws IOException {
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(new File("big.jar")));
        zos.putNextEntry(new ZipEntry("resource.txt"));
        zos.write("not too much in here".getBytes());
        zos.closeEntry();
        zos.putNextEntry(new ZipEntry("largeFile.out"));
        for (int i=0 ; i<10000000 ; i++) {
            zos.write((int) (Math.round(Math.random()*100)+20));
        }
        zos.closeEntry();
        zos.close();
    }
}

只需粘贴到名为BigJarCreator.java的文件中，从命令行编译并运行它：

javac BigJarCreator.java
java -cp . BigJarCreator

等等：您在当前工作目录中找到一个jar存档，其中包含两个文件。

让我们创建第二个类：

public class MemLeak {
    public static void main(String[] args) throws InterruptedException {
        int ITERATIONS=100000;
        for (int i=0 ; i<ITERATIONS ; i++) {
            MemLeak.class.getClassLoader().getResourceAsStream("resource.txt");
        }
        System.out.println("finished creation of streams, now waiting to be killed");

        Thread.sleep(Long.MAX_VALUE);
    }

}

这个类基本上什么都不做，只创建未引用的InputStream对象。这些对象将立即被垃圾收集，因此不会影响堆大小。对于我们的示例来说，从jar文件加载现有资源很重要，这里的大小很重要！

如果您有疑问，请尝试编译并启动上面的类，但确保选择了合适的堆大小（2MB）：

javac MemLeak.java
java -Xmx2m -classpath .:big.jar MemLeak

在这里您不会遇到OOM错误，因为没有保留引用，所以无论您在上面的示例中选择了多大的ITERATIONS，应用程序都将继续运行。除非应用程序执行wait命令，否则进程的内存消耗（在顶部（RES/RSS）或进程资源管理器中可见）会增加。在上面的设置中，它将分配大约150 MB的内存。

如果希望应用程序安全运行，请在创建输入流的位置关闭输入流：

MemLeak.class.getClassLoader().getResourceAsStream("resource.txt").close();

并且您的进程不会超过35MB，与迭代计数无关。

非常简单和令人惊讶。

您可以使用sun.misc.Unsafe类进行内存泄漏。事实上，这个服务类用于不同的标准类（例如java.nio类）。不能直接创建此类的实例，但可以使用反射来获取实例。

代码不会在EclipseIDE中编译-使用javac命令编译代码（编译期间，您会收到警告）

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import sun.misc.Unsafe;

public class TestUnsafe {

    public static void main(String[] args) throws Exception{
        Class unsafeClass = Class.forName("sun.misc.Unsafe");
        Field f = unsafeClass.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe unsafe = (Unsafe) f.get(null);
        System.out.print("4..3..2..1...");
        try
        {
            for(;;)
                unsafe.allocateMemory(1024*1024);
        } catch(Error e) {
            System.out.println("Boom :)");
            e.printStackTrace();
        }
    }
}