java内存泄露代码实例 java jni内存泄露

什么原因可导致java内存泄漏？

Java内存泄露\x0d\x0a\x0d\x0a一般来说内存泄漏有两种情况。一种情况如在C/C++语言中的，在堆中的分配的内存，在没有将其释放掉的时候，就将所有能访问这块内存的方式都删掉（如指针重新赋值）；另一种情况则是在内存对象明明已经不需要的时候，还仍然保留着这块内存和它的访问方式（引用）。第一种情况，在Java中已经由于垃圾回收机制的引入，得到了很好的解决。所以，Java中的内存泄漏，主要指的是第二种情况。\x0d\x0a 可能光说概念太抽象了，大家可以看一下这样的例子：\x0d\x0a\x0d\x0a1 Vector v=new Vector(10);\x0d\x0a2 for (int i=1;i

成都创新互联公司长期为千余家客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为东昌府企业提供专业的成都网站设计、成都做网站，东昌府网站改版等技术服务。拥有十载丰富建站经验和众多成功案例,为您定制开发。

回答于 2022-12-11

如何编写一个java内存泄露程序？

自己改一下下面的代码，把堆栈中的元素改成mp3类型的或更大点的东西

4.Java中参数都是传值的。

对于基本类型，大家基本上没有异议，但是对于引用类型我们也不能有异议。

Java内存泄露情况

JVM回收算法 是很复杂的，我也不知道他们怎么实现的，但是我只知道他们要实现的就是：对于没有被引用的对象是可以回收的。所以你要造成内存泄露就要做到：

持有对无用对象的引用!

不要以为这个很轻易做到，既然无用，你怎么还会持有它的引用? 既然你还持有它，它怎么会是无用的呢?

以下以堆栈更经典这个经典的例子来剖析。

Java代码

public class Stack {

private Object[] elements=new Object[10];

private int size = 0;

public void push(Object e){

ensureCapacity();

elements[size++] = e;

}

public Object pop(){

if( size == 0)

throw new EmptyStackException();

return elements[--size];

}

private void ensureCapacity(){

if(elements.length == size){

Object[] oldElements = elements;

elements = new Object[2 * elements.length+1];

System.arraycopy(oldElements,0, elements, 0, size);

}

}

}

上面的原理应该很简单，假如堆栈加了10个元素，然后全部弹出来，虽然堆栈是空的，没有我们要的东西，但是这是个对象是无法回收的，这个才符合了内存泄露的两个条件：无用，无法回收。

但是就是存在这样的东西也不一定会导致什么样的后果，假如这个堆栈用的比较少，也就浪费了几个K内存而已，反正我们的内存都上G了，哪里会有什么影响，再说这个东西很快就会被回收的，有什么关系。下面看两个例子。

例子1

Java代码

public class Bad{

public static Stack s=Stack();

static{

s.push(new Object());

s.pop(); //这里有一个对象发生内存泄露

s.push(new Object()); //上面的对象可以被回收了，等于是自愈了

}

}

因为是static，就一直存在到程序退出，但是我们也可以看到它有自愈功能 ，就是说假如你的Stack最多有100个对象，那么最多也就只有100个对象无法被回收其实这个应该很轻易理解，Stack内部持有100个引用，最坏的情况就是他们都是无用的，因为我们一旦放新的进取，以前的引用自然消失！

例子2

Java代码

public class NotTooBad{

public void doSomething(){

Stack s=new Stack();

s.push(new Object());

//other code

s.pop();//这里同样导致对象无法回收,内存泄露.

}//退出方法,s自动无效,s可以被回收,Stack内部的引用自然没了,所以

//这里也可以自愈,而且可以说这个方法不存在内存泄露问题,不过是晚一点

//交给GC而已,因为它是封闭的,对外不开放,可以说上面的代码99.9999%的

//情况是不会造成任何影响的,当然你写这样的代码不会有什么坏的影响,但是

//绝对可以说是垃圾代码!没有矛盾吧,我在里面加一个空的for循环也不会有

//什么太大的影响吧,你会这么做吗?

}

如何用Java编写一段代码引发内存泄露

A1：通过以下步骤可以很容易产生内存泄露（程序代码不能访问到某些对象，但是它们仍然保存在内存中）:

应用程序创建一个长时间运行的线程（或者使用线程池，会更快地发生内存泄露）。

线程通过某个类加载器（可以自定义）加载一个类。

该类分配了大块内存（比如new byte[1000000]），在某个静态变量存储一个强引用，然后在ThreadLocal中存储它自身的引用。分配额外的内存new byte[1000000]是可选的(类实例泄露已经足够了)，但是这样会使内存泄露更快。

线程清理自定义的类或者加载该类的类加载器。

重复以上步骤。

由于没有了对类和类加载器的引用，ThreadLocal中的存储就不能被访问到。ThreadLocal持有该对象的引用，它也就持有了这个类及其类加载器的引用，类加载器持有它所加载的类的所有引用，这样GC无法回收ThreadLocal中存储的内存。在很多JVM的实现中Java类和类加载器直接分配到permgen区域不执行GC，这样导致了更严重的内存泄露。

这种泄露模式的变种之一就是如果你经常重新部署以任何形式使用了ThreadLocal的应用程序、应用容器（比如Tomcat）会很容易发生内存泄露（由于应用容器使用了如前所述的线程，每次重新部署应用时将使用新的类加载器）。

A2：

静态变量引用对象

class MemorableClass {

static final ArrayList list = new ArrayList(100);

}

调用长字符串的String.intern()

1

2

3

String str=readString(); // read lengthy string any source db,textbox/jsp etc..

// This will place the string in memory pool from which you cant remove

str.intern();

未关闭已打开流(文件，网络等)

try {

BufferedReader br = new BufferedReader(new FileReader(inputFile));

...

...

} catch (Exception e) {

e.printStacktrace();

}

未关闭连接

try {

Connection conn = ConnectionFactory.getConnection();

...

...

} catch (Exception e) {

e.printStacktrace();

}

JVM的GC不可达区域

比如通过native方法分配的内存。

web应用在application范围的对象，应用未重启或者没有显式移除

getServletContext().setAttribute("SOME_MAP", map);

web应用在session范围的对象，未失效或者没有显式移除

session.setAttribute("SOME_MAP", map);

不正确或者不合适的JVM选项

比如IBM JDK的noclassgc阻止了无用类的垃圾回收

A3：如果HashSet未正确实现(或者未实现)hashCode()或者equals(),会导致集合中持续增加“副本”。如果集合不能地忽略掉它应该忽略的元素，它的大小就只能持续增长，而且不能删除这些元素。

如果你想要生成错误的键值对，可以像下面这样做：

class BadKey {

// no hashCode or equals();

public final String key;

public BadKey(String key) { this.key = key; }

}

Map map = System.getProperties();

map.put(new BadKey("key"), "value"); // Memory leak even if your threads die.

A4：除了被遗忘的监听器，静态引用，hashmap中key错误/被修改或者线程阻塞不能结束生命周期等典型内存泄露场景，下面介绍一些不太明显的Java发生内存泄露的情况，主要是线程相关的。

Runtime.addShutdownHook后没有移除，即使使用了removeShutdownHook，由于ThreadGroup类对于未启动线程的bug，它可能不被回收，导致ThreadGroup发生内存泄露。

创建但未启动线程，与上面的情形相同

创建继承了ContextClassLoader和AccessControlContext的线程，ThreadGroup和InheritedThreadLocal的使用，所有这些引用都是潜在的泄露，以及所有被类加载器加载的类和所有静态引用等等。这对ThreadFactory接口作为重要组成元素整个j.u.c.Executor框架(java.util.concurrent)的影响非常明显，很多开发人员没有注意到它潜在的危险。而且很多库都会按照请求启动线程。

ThreadLocal缓存，很多情况下不是好的做法。有很多基于ThreadLocal的简单缓存的实现，但是如果线程在它的期望生命周期外继续运行ContextClassLoader将发生泄露。除非真正必要不要使用ThreadLocal缓存。

当ThreadGroup自身没有线程但是仍然有子线程组时调用ThreadGroup.destroy()。发生内存泄露将导致该线程组不能从它的父线程组移除，不能枚举子线程组。

使用WeakHashMap，value直接(间接)引用key，这是个很难发现的情形。这也适用于继承Weak/SoftReference的类可能持有对被保护对象的强引用。

使用http(s)协议的java.net.URL下载资源。KeepAliveCache在系统ThreadGroup创建新线程，导致当前线程的上下文类加载器内存泄露。没有存活线程时线程在第一次请求时创建，所以很有可能发生泄露。(在Java7中已经修正了，创建线程的代码合理地移除了上下文类加载器。)

使用InflaterInputStream在构造函数(比如PNGImageDecoder)中传递new java.util.zip.Inflater()，不调用inflater的end()。仅仅是new的话非常安全，但如果自己创建该类作为构造函数参数时调用流的close()不能关闭inflater，可能发生内存泄露。这并不是真正的内存泄露因为它会被finalizer释放。但这消耗了很多native内存，导致linux的oom_killer杀掉进程。所以这给我们的教训是：尽可能早地释放native资源。

java.util.zip.Deflater也一样，它的情况更加严重。好的地方可能是很少用到Deflater。如果自己创建了Deflater或者Inflater记住必须调用end()。