求java 内存泄漏例子

Question

内存泄露是指一段内存不能被回收，也不能被访问。可是java中不能访问的就回收了，想要泄露估计是很特别的方法才能达到。要不写个本地方法，用C泄露，maloc一段内存，然后把指针扔掉....

Answer 1

谢谢楼上的两位解答从C/C++来看，如果一段code存在内存泄漏，那么可以分配的内存会越来越少，
如果无限循环这段code最后肯定会导致程序死掉
难道java的内存泄漏不是这样吗？求指正

Answer 2

定义一个list，循环插入数据不就可以了，不过首先把java的虚拟内存设置小效果比较好

Answer 3

这个list里面的内容最好都是对象，并且还有子对象，效果更好，我之前常遇到的事

Answer 4

是这样没错
但是如果无限循环调用一段有存在内存泄漏的code，
那么最后肯定会因为内存耗尽而死掉

Answer 5

例子：
import java.util.Arrays;
import java.util.EmptyStackException;// Can you spot the "memory leak"?
public class Stack {
    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    private Object[] elements;
    private int size = 0;    public Stack() {
        elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }    public static void main(String[] args) {
        Stack stack = new Stack();
        while (true) {
            stack.push("");
            stack.pop();
        }
    }    public void push(Object e) {
        ensureCapacity();
        elements[size++] = e;
    }    public Object pop() {
        if (size == 0)
            throw new EmptyStackException();
        return elements[--size];
    }    /**
     * Ensure space for at least one more element, roughly
     * doubling the capacity each time the array needs to grow.
     */
    private void ensureCapacity() {
        if (elements.length == size)
            elements = Arrays.copyOf(elements, 2 * size + 1);
    }
}工具：
http://visualvm.java.net/download.html下载个VisualVM 1.3.8，观看程序运行时内存的使用状况如果想早点儿让系统崩溃，可以考虑把虚拟内存先关了
如果物理内存还很大的话，可以考虑下载个ramdisk工具，把大部分内存虚拟成硬盘……(⊙o⊙)哦，小心蓝屏

Answer 6

public class Test {
public static void main(String[] args) {
List<OOM> list = new ArrayList<>();
while(true){
list.add(new OOM());
}
}
static class OOM{
}
}
这是《深入理解java虚拟机中》，书里面2.4节介绍了内存泄露的例子，有好几个很精巧的例子，可以去看看，解释的也非常好。

Answer 7

java还是比较严谨,内存泄露的例子比较少,大部分都是异常，

Answer 8

首先谢谢大家的回复不过可惜的是 好像大家都没有搞清楚一些基本概念内存溢出就是你要求分配的内存超出了系统能给你的，系统不能满足需求，于是产生溢出。   
内存泄漏就是没有及时清理内存垃圾，导致系统无法再给你提供内存资源（内存资源耗尽）。内存泄露是程序逻辑问题，造成申请的内存无法释放。
这样的话无论多少内存，早晚都会被占用光的.不改程序补bug是没法治好的.

Answer 9

1、静态集合类引起内存泄露： 
像HashMap、Vector等的使用最容易出现内存泄露，这些静态变量的生命周期和应用程序一致，他们所引用的所有的对象Object也不能被释放，因为他们也将一直被Vector等引用着。 
例: 
Static Vector v = new Vector(10); 
for (int i = 1; i<100; i++) 
{ 
Object o = new Object(); 
v.add(o); 
o = null; 
}// 
在这个例子中，循环申请Object 对象，并将所申请的对象放入一个Vector 中，如果仅仅释放引用本身（o=null），那么Vector 仍然引用该对象，所以这个对象对GC 来说是不可回收的。因此，如果对象加入到Vector 后，还必须从Vector 中删除，最简单的方法就是将Vector对象设置为null。 2、当集合里面的对象属性被修改后，再调用remove（）方法时不起作用。 例： 
public static void main(String[] args)  
{  
Set<Person> set = new HashSet<Person>();  
Person p1 = new Person("唐僧","pwd1",25);  
Person p2 = new Person("孙悟空","pwd2",26);  
Person p3 = new Person("猪八戒","pwd3",27);  
set.add(p1);  
set.add(p2);  
set.add(p3);  
System.out.println("总共有:"+set.size()+" 个元素!");  //结果：总共有:3 个元素!   
p3.setAge(2);    //修改p3的年龄,此时p3元素对应的hashcode值发生改变   
set.remove(p3);  //此时remove不掉，造成内存泄漏   
set.add(p3);     //重新添加，居然添加成功   
System.out.println("总共有:"+set.size()+" 个元素!");  //结果：总共有:4 个元素!   
for (Person person : set)  
{  
        System.out.println(person);  
}   
}  3、监听器 
     在java 编程中，我们都需要和监听器打交道，通常一个应用当中会用到很多监听器，我们会调用一个控件的诸如addXXXListener()等方法来增加监听器，但往往在释放对象的时候却没有记住去删除这些监听器，从而增加了内存泄漏的机会。 4、各种连接 
比如数据库连接（dataSourse.getConnection()），网络连接(socket)和io连接，除非其显式的调用了其close（）方法将其连接关闭，否则是不会自动被GC 回收的。对于Resultset 和Statement 对象可以不进行显式回收，但Connection 一定要显式回收，因为Connection 在任何时候都无法自动回收，而Connection一旦回收，Resultset 和Statement 对象就会立即为NULL。但是如果使用连接池，情况就不一样了，除了要显式地关闭连接，还必须显式地关闭Resultset Statement 对象（关闭其中一个，另外一个也会关闭），否则就会造成大量的Statement 对象无法释放，从而引起内存泄漏。这种情况下一般都会在try里面去的连接，在finally里面释放连接。 5、内部类和外部模块等的引用 
    内部类的引用是比较容易遗忘的一种，而且一旦没释放可能导致一系列的后继类对象没有释放。此外程序员还要小心外部模块不经意的引用，例如程序员A 负责A 模块，调用了B 模块的一个方法如： 
public void registerMsg(Object b); 
这种调用就要非常小心了，传入了一个对象，很可能模块B就保持了对该对象的引用，这时候就需要注意模块B 是否提供相应的操作去除引用。 6、单例模式 
  不正确使用单例模式是引起内存泄露的一个常见问题，单例对象在被初始化后将在JVM的整个生命周期中存在（以静态变量的方式），如果单例对象持有外部对象的引用，那么这个外部对象将不能被jvm正常回收，导致内存泄露，考虑下面的例子： 
class A{ 
　　public A(){ 
　　      B.getInstance().setA(this); 
} 
　　.... 
} 
　　//B类采用单例模式 
class B{ 
　　private A a; 
　　private static B instance=new B(); 
　　public B(){} 
　　public static B getInstance(){ 
　　 return instance; 
　　} 
　　public void setA(A a){ 
　　 this.a=a; 
　　} 
　　//getter... 
} 
　　显然B采用singleton模式，它持有一个A对象的引用，而这个A类的对象将不能被回收。想象下如果A是个比较复杂的对象或者集合类型会发生什么情况。 
     

Answer 10

读取大文件! nice求分

Answer 11

在来, 不端平均stringbuffer 导致内存溢出! 求分

Answer 12

内存泄漏和内存溢出是有区别的
1.Java内存泄露是说程序逻辑问题,造成申请的内存无法释放.这样的话无论多少内存,早晚都会被占用光的.
最简单的例子就是死循环了.由于程序判断错误导经常发生此事2.Java内存泄漏是指在堆上分配的内存没有被释放，从而失去对其控制。这样会造成程序能使用的内存越来越少，导致系统运行速度减慢，严重情况会使程序当掉。3.关于内存溢出有点出入。比如说你申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。

Answer 13

java内存是自动管理的，你不用了虚拟机就忙你干了

Answer 14

看一个ArrayList 中的防止内存泄露的代码
    /**
     * Removes the element at the specified position in this list.
     * Shifts any subsequent elements to the left (subtracts one from their
     * indices).
     *
     * @param index the index of the element to be removed
     * @return the element that was removed from the list
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E remove(int index) {
        rangeCheck(index);        modCount++;
        E oldValue = elementData(index);        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work        return oldValue;
    }
arrayList 是动态数组，它的底层是通过数组实现的，跟数组不同的是，它的对象超过现有的数组分配时，会自动给数组扩容
如果删除一个对象时，也 必须将数组里面对应的对象连接置空，置为null，此时，该对象便不再有变量指向，GC适时会将该对象收集，如果缺少了elementData[--size] = null; // clear to let GC do its work ，对象是不在list中了，但是数组中依然存在对它的引用，导致GC无法对该对象进行收集，造成内存泄露。

Answer 15

这个程序没有内存泄漏

这个程序有内存泄露，这个例子中的代码跟你的例子泄露情况是一样的，都是没有将数组中对对象的引用置空。
内存泄露和泄露后报异常出来是两回事，楼主想找的是泄露后能让JVM宕掉的例子，楼主的例子和上面的例子，都没有让JVM宕掉。将数组里面的对象换成大对象，同时将jvm的运行时堆内存调低一些，应该可以达到楼主的目的。

Answer 16

看起来 java应该是没有C++中那种泄漏，即使是泄漏也是泄漏一点点
是这样 吗，谢谢

Answer 17

Java内存泄露的理解与解决

Answer 18

C++ 的内存泄露，不懂。
java的内存泄露，不能讲泄露一点点。一处泄露一点点，地方多了，或代码运行久了，就会造成系统崩盘了。

Answer 19

C++ 的内存泄露，不懂。
java的内存泄露，不能讲泄露一点点。一处泄露一点点，地方多了，或代码运行久了，就会造成系统崩盘了。谢谢指正
实际code中真有多个地方一点点泄漏最后导致系统崩盘了？

Answer 20

C++ 的内存泄露，不懂。
java的内存泄露，不能讲泄露一点点。一处泄露一点点，地方多了，或代码运行久了，就会造成系统崩盘了。谢谢指正
实际code中真有多个地方一点点泄漏最后导致系统崩盘了？java 的内存泄露和C++的内存刚好相反。C++的内存问题主要是源于 你申请了内存(malloc)，用完了之后，你没有释放掉(free)，而你自己的程序已经把指向该片内存的指针释放了，到最后，你的程序根本就不知道自己申请了这片内存，导致内存用光了。而java则正好相反，上述这情况下，JVM会自动回收内存。java 的内存泄露主要原因是，你在的业务逻辑结束后，你还有对像引用着相关的对像，如上述例子中，主要是用一个stack来描述内存问题的，当stack中pop一个元素以后，对stack而言，业务逻辑已经结束了，顶上的对像实例应该被释放掉。但因为stack实现上的问题，stack顶以上的部分仍然还指向相关的对像引用。因此称之为内存泄露。还有一点，我也想提醒你的，java 内存泄露和OutOfMemory 出现的关系，是需要时间的，和你jvm的mx的配置有关系。同时，出现OutOfMemory也未必代表你代码有问题，不出现OutOfMemory也不代表你的代码一定没问题。这句很难懂吧，意思是说，出现OutOfMemory有可能是你的业务导致内存不够用，如为了读文件，把若干G的文件一下子读进内存，申请了暴大的内存也会导致OutOfMemory。反之，任何bug都有触发条件 ，跑的业务如果触发bug的量不够，不定会堆到OutOfMemory的地步。但判定内存泄露问题并不一定要等到OutOfMemory才确认，只要你的代码跑够了足够多的full gc，通过内存和你业务之间的关系就可以大致进行判定。最后，分享推荐上周和人讨论的一个真实的例子
http://bbs.csdn.net/topics/390983287

Answer 21

java内存泄露很常见的一个例子就是集合类使用完没有销毁。