不终止的线程（比如在其运行方法中无限期休眠）。即使我们丢失了对它的引用，它也不会被垃圾收集。您可以添加字段以使线程对象变大。

目前排名靠前的答案列出了更多的技巧，但这些似乎是多余的。

可能是潜在内存泄漏以及如何避免它的最简单示例之一，是ArrayList.remove（int）的实现：

public E remove(int index) {
    RangeCheck(index);

    modCount++;
    E oldValue = (E) elementData[index];

    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index + 1, elementData, index,
                numMoved);
    elementData[--size] = null; // (!) Let gc do its work

    return oldValue;
}

如果您是自己实现的，您是否想过清除不再使用的数组元素（elementData[-size]=null）？该引用可能会使一个巨大的对象保持活力。。。

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

考虑：终止工作线程的基本模式是设置线程看到的一些条件变量。线程可以定期检查变量，并将其作为终止的信号。如果变量未声明为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中的内存泄漏不是典型的C/C++内存泄漏。

要了解JVM的工作原理，请阅读了解内存管理。

基本上，重要的部分是：

标记和扫描模型JRockit JVM使用标记和清除垃圾收集模型执行整个堆的垃圾收集。标记和扫描垃圾收集包括两个阶段，标记阶段和扫描阶段。在标记阶段，可以从Java访问的所有对象线程、本机句柄和其他根源标记为活动的，如以及可从这些对象访问的对象，等等向前地此过程识别并标记所有静止的对象使用，其余的可以被视为垃圾。在扫描阶段，将遍历堆以查找活动对象。这些差距记录在免费列表中可用于新对象分配。JRockit JVM使用标记和扫描的两个改进版本模型一种是同时进行标记和扫描，另一种是平行标记和扫描。你也可以将这两种策略结合起来例如主要是并发标记和并行扫描。

因此，在Java中创建内存泄漏；最简单的方法是创建一个数据库连接，做一些工作，而不是Close（）；然后在保持范围内的同时生成新的数据库连接。例如，这在循环中并不难做到。如果您有一个工作人员从队列中拉出并推送到数据库，那么您可以通过忘记Close（）连接或在不需要时打开连接等方式轻松创建内存泄漏。

最终，您将通过忘记Close（）连接来消耗已分配给JVM的堆。这将导致JVM垃圾疯狂收集；最终导致java.lang.OutOfMemoryError:java堆空间错误。应该注意，该错误可能并不意味着存在内存泄漏；这可能意味着你没有足够的记忆；例如，Cassandra和Elasticsearch等数据库可能会抛出错误，因为它们没有足够的堆空间。

值得注意的是，所有GC语言都是如此。以下是我作为SRE工作的一些例子：

Node.js使用Redis作为队列；开发团队每12小时创建一次新连接，但忘记关闭旧连接。最终，节点是OOMd，因为它消耗了所有内存。去吧（我犯了这个罪）；使用JSON.Unmarshal解析大型JSON文件，然后通过引用传递结果并保持其打开状态。最终，这导致整个堆被我打开以解码JSON的意外引用所消耗。

我最近遇到了由log4j引起的内存泄漏情况。

Log4j有一种称为嵌套诊断上下文（NDC）的机制，它是一种区分不同来源的交织日志输出的工具。NDC工作的粒度是线程，因此它区分不同线程的日志输出。

为了存储线程特定的标记，log4j的NDC类使用一个Hashtable，该Hashtable由thread对象本身（而不是线程id）键控，因此直到NDC标记保留在内存中，挂在线程对象上的所有对象也保留在内存。在我们的web应用程序中，我们使用NDC标记带有请求id的登录，以将日志与单个请求区分开来。将NDC标记与线程关联的容器在返回请求响应时也会将其删除。在处理请求的过程中，产生了一个子线程，类似于以下代码：

pubclic class RequestProcessor {
    private static final Logger logger = Logger.getLogger(RequestProcessor.class);
    public void doSomething()  {
        ....
        final List<String> hugeList = new ArrayList<String>(10000);
        new Thread() {
           public void run() {
               logger.info("Child thread spawned")
               for(String s:hugeList) {
                   ....
               }
           }
        }.start();
    }
}    

因此，NDC上下文与派生的内联线程相关联。这个NDC上下文的关键线程对象是一个内联线程，它挂着hugeList对象。因此，即使线程完成了它正在做的事情，对hugeList的引用也会被NDC上下文Hastable保持活动状态，从而导致内存泄漏。

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

public class Main {
    public static void main(String args[]) {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            ((Unsafe) f.get(null)).allocateMemory(2000000000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}