我觉得有趣的是，没有人使用内部类示例。如果您有内部类；它固有地维护对包含类的引用。当然，从技术上讲，这不是内存泄漏，因为Java最终会清理掉它；但这会导致类停留的时间比预期的长。

public class Example1 {
  public Example2 getNewExample2() {
    return this.new Example2();
  }
  public class Example2 {
    public Example2() {}
  }
}

现在，如果您调用Example1并得到一个Example2丢弃Example1，那么您本质上仍然有一个到Example1对象的链接。

public class Referencer {
  public static Example2 GetAnExample2() {
    Example1 ex = new Example1();
    return ex.getNewExample2();
  }

  public static void main(String[] args) {
    Example2 ex = Referencer.GetAnExample2();
    // As long as ex is reachable; Example1 will always remain in memory.
  }
}

我还听到一个传言，如果你有一个变量存在的时间超过了一个特定的时间；Java假设它将永远存在，并且如果代码中无法访问它，它实际上永远不会尝试清理它。但这完全未经证实。

在具有自己生命周期的类中随意使用非静态内部类。

在Java中，非静态内部类和匿名类对其外部类具有隐式引用。另一方面，静态内部类则不然。

下面是一个常见的Android内存泄漏示例，但这并不明显：

public class SampleActivity extends Activity {

  private final Handler mLeakyHandler = new Handler() { // Non-static inner class, holds the reference to the SampleActivity outer class
    @Override
    public void handleMessage(Message msg) {
      // ...
    }
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Post a message and delay its execution for a long time.
    mLeakyHandler.postDelayed(new Runnable() {//here, the anonymous inner class holds the reference to the SampleActivity class too
      @Override
      public void run() {
     //....
      }
    }, SOME_TOME_TIME);

    // Go back to the previous Activity.
    finish();
  }}

这将防止活动上下文被垃圾收集。

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

考虑：终止工作线程的基本模式是设置线程看到的一些条件变量。线程可以定期检查变量，并将其作为终止的信号。如果变量未声明为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的对象永远不会死。

如果您不了解JDBC，下面是一个毫无意义的示例。或者至少是JDBC希望开发人员在丢弃Connection、Statement和ResultSet实例或丢失对它们的引用之前关闭它们，而不是依赖于实现finalize方法。

void doWork() {
    try {
        Connection conn = ConnectionFactory.getConnection();
        PreparedStatement stmt = conn.preparedStatement("some query");
        // executes a valid query
        ResultSet rs = stmt.executeQuery();
        while(rs.hasNext()) {
            // ... process the result set
        }
    } catch(SQLException sqlEx) {
        log(sqlEx);
    }
}

上面的问题是Connection对象没有关闭，因此物理Connection将保持打开状态，直到垃圾回收器返回并发现它不可访问为止。GC将调用finalize方法，但有些JDBC驱动程序没有实现finalize，至少与Connection.close的实现方式不同。由此产生的行为是，尽管JVM将由于收集不可访问的对象而回收内存，但与Connection对象关联的资源（包括内存）可能不会被回收。

因此，Connection的最终方法并不能清除所有内容。人们可能会发现，到数据库服务器的物理连接将持续几个垃圾收集周期，直到数据库服务器最终发现该连接不活动（如果存在），应该关闭。

即使JDBC驱动程序实现了finalize，编译器也可以在finalize期间抛出异常。由此产生的行为是，与现在“休眠”对象关联的任何内存都不会被编译器回收，因为finalize保证只被调用一次。

上述在对象完成过程中遇到异常的场景与另一种可能导致内存泄漏的场景有关——对象复活。对象复活通常是通过创建一个从另一个对象最终确定的对象的强引用来实现的。当对象复活被误用时，它将与其他内存泄漏源一起导致内存泄漏。

还有很多例子你可以想象出来

管理列表实例，其中您只添加到列表中，而不从列表中删除（尽管您应该删除不再需要的元素），或者打开套接字或文件，但不再需要时不关闭它们（类似于上面涉及Connection类的示例）。在关闭Java EE应用程序时不卸载Singleton。加载单例类的Classloader将保留对该类的引用，因此JVM永远不会收集单例实例。当部署应用程序的新实例时，通常会创建一个新的类加载器，而由于单例，前一个类加载器将继续存在。

我想就如何使用JVM中可用的工具监视应用程序的内存泄漏提供建议。它没有显示如何生成内存泄漏，但解释了如何使用最少的可用工具检测内存泄漏。

您需要首先监视Java内存消耗。

最简单的方法是使用JVM附带的jstat实用程序：

jstat -gcutil <process_id> <timeout>

它将报告每一代（年轻、老年和老年）的内存消耗和垃圾收集时间（年轻和完整）。

一旦您发现一个完整的垃圾收集执行得太频繁并且花费了太多时间，您就可以假设应用程序正在泄漏内存。

然后需要使用jmap实用程序创建内存转储：

jmap -dump:live,format=b,file=heap.bin <process_id>

然后需要使用内存分析器（例如Eclipse memory Analyzer（MAT））分析heap.bin文件。

MAT将分析内存并向您提供有关内存泄漏的可疑信息。

下面将有一个不明显的Java泄漏案例，除了被遗忘的侦听器、静态引用、哈希图中的伪/可修改键，或者只是线程被卡住而没有机会结束其生命周期的标准案例之外。

File.deleteOnExit（）-总是泄漏字符串，如果字符串是子字符串，则泄漏更严重（底层的char[]也泄漏）-在Java 7中，子字符串也会复制char[]，因此后者不适用@丹尼尔，不过不需要投票。

我将集中讨论线程，以展示非托管线程的危险性，甚至不希望触及摆动。

Runtime.addShutdownHook，不删除。。。然后，即使使用removeShutdownHook，由于ThreadGroup类中关于未启动线程的错误，它也可能无法被收集，从而有效地泄漏了ThreadGroup。JGroup在GossipRouter中有漏洞。创建一个线程，但不是启动它，它属于与上面相同的类别。创建线程继承ContextClassLoader和AccessControlContext，加上ThreadGroup和任何InheritedThreadLocal，所有这些引用都是潜在的泄漏，以及类加载器加载的所有类和所有静态引用，以及ja-ja。这种效果在整个j.u.c.Executor框架中尤其明显，该框架具有超简单的ThreadFactory接口，但大多数开发人员对潜在的危险一无所知。此外，许多库确实会根据请求启动线程（太多行业流行的库）。ThreadLocal缓存；这些在很多情况下都是邪恶的。我相信每个人都看到过很多基于ThreadLocal的简单缓存，但坏消息是：如果线程在上下文ClassLoader的生命周期中继续运行超过预期，这是一个非常好的小泄漏。除非确实需要，否则不要使用ThreadLocal缓存。当ThreadGroup本身没有线程，但仍保留子ThreadGroups时，调用ThreadGroup.destroy（）。一个严重的泄漏，将阻止ThreadGroup从其父级中删除，但所有子级都无法枚举。使用WeakHashMap和值（in）直接引用键。如果没有堆转储，这很难找到。这适用于可能将硬引用保留回受保护对象的所有扩展弱/软引用。将java.net.URL与HTTP（S）协议一起使用，并从（！）加载资源。这一个是特殊的，KeepAliveCache在系统ThreadGroup中创建了一个新线程，该线程泄漏了当前线程的上下文类加载器。当不存在活动线程时，线程会在第一个请求时创建，因此您可能会幸运，或者只是泄漏。泄漏在Java7中已经修复，创建线程的代码正确地删除了上下文类加载器。创建类似线程的情况很少（如ImageFetcher，也已修复）。使用充气器InputStream在构造函数（例如PNGImageDecoder）中传递新的java.util.zip充气器（），而不调用充气器的end（）。好吧，如果你只传递一个新的构造函数，就没有机会。。。是的，如果将其作为构造函数参数手动传递，则对流调用close（）不会关闭充气机。这不是真正的泄漏，因为它将由终结器释放。。。当它认为有必要时。直到那一刻，它会严重消耗本地内存，导致Linux oom_killer肆无忌惮地终止进程。主要的问题是，在Java中完成是非常不可靠的，G1使其更糟，直到7.0.2。故事的寓意：尽快释放本土资源；终结器太差了。与java.util.zip.Deflater的情况相同。这一情况更糟，因为Deflater在java中需要内存，即总是使用15位（最大值）和8个内存级别（最大值为9）来分配数百KB的本地内存。幸运的是，Deflater没有被广泛使用，据我所知，JDK没有任何误用。如果手动创建放气器或充气器，请始终调用end（）。最后两种方法中最棒的一点是：您无法通过常规的分析工具找到它们。

（我可以根据要求再添加一些我遇到的时间浪费者。）

祝你好运，保持安全；泄漏是邪恶的！