java中避免内存泄漏应该注意哪些？

java有内存回收机制, java虚拟机有个单独线程专门维护垃圾内存, 每隔一段时间会检查一次.

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：主机域名、雅安服务器托管、营销软件、网站建设、弋阳网站维护、网站推广。

只有new申请内存, 没有delete. 你没法主动释放内存.

你不用担心内存泄漏. 如果你想要一块内存释放的话, 你只需将这个引用置为null

比如StringBuffer sb = new StringBuffer();

// 使用中...

sb = null; // sb指向的内存空间已没有人引用了, 下次回收机制就会回收

你也可以手动执行让虚拟机马上执行一次回收, 它会马上检查一次. 但不建议经常这么做, 影响效率.

System.gc();

如何避免java程序内存泄漏

不好处理，保证写的代码没有死循环，没有未关闭的流等等。横向扩展功能，用负载均衡啥的，减少某一台服务器的承载

java如何防止内存泄露？

java的垃圾回收器，会在对象废弃过后，自动去找到他们，然后去清理内存，释放被占用的内存，可以防止内存的泄露，像c++等语言，对象创建后，如果不手动去释放内存，就会很容易造成内存泄露

java内存泄漏怎么解决

一般情况下内存泄漏的避免

在不涉及复杂数据结构的一般情况下，Java 的内存泄露表现为一个内存对象的生命周期超出了程序需要它的时间长度。我们有时也将其称为“对象游离”。

例如：

public class FileSearch{ private byte [] content; private File mFile; public FileSearch(File file){ mFile = file; } public boolean hasString(String str){ int size = getFileSize(mFile); content = new byte [size]; loadFile(mFile, content); String s = new String(content); return s.contains(str); }}

在这段代码中，FileSearch 类中有一个函数 hasString ，用来判断文档中是否含有指定的字符串。流程是先将mFile 加载到内存中，然后进行判断。但是，这里的问题是，将 content 声明为了实例变量，而不是本地变量。于是，在此函数返回之后，内存中仍然存在整个文件的数据。而很明显，这些数据我们后续是不再需要的，这就造成了内存的无故浪费。

要避免这种情况下的内存泄露，要求我们以C/C++ 的内存管理思维来管理自己分配的内存。第一，是在声明对象引用之前，明确内存对象的有效作用域。在一个函数内有效的内存对象，应该声明为 local 变量，与类实例生命周期相同的要声明为实例变量……以此类推。第二，在内存对象不再需要时，记得手动将其引用置空。

复杂数据结构中的内存泄露问题

在实际的项目中，我们经常用到一些较为复杂的数据结构用于缓存程序运行过程中需要的数据信息。有时，由于数据结构过于复杂，或者我们存在一些特殊的需求（例如，在内存允许的情况下，尽可能多的缓存信息来提高程序的运行速度等情况），我们很难对数据结构中数据的生命周期作出明确的界定。这个时候，我们可以使用Java 中一种特殊的机制来达到防止内存泄露的目的。

之前我们介绍过，Java 的 GC 机制是建立在跟踪内存的引用机制上的。而在此之前，我们所使用的引用都只是定义一个“ Object o; ”这样形式的。事实上，这只是 Java 引用机制中的一种默认情况，除此之外，还有其他的一些引用方式。通过使用这些特殊的引用机制，配合 GC 机制，就可以达到一些我们需要的效果。

Java中的几种引用方式

Java中有几种不同的引用方式，它们分别是：强引用、软引用、弱引用和虚引用。下面，我们首先详细地了解下这几种引用方式的意义。

强引用

在此之前我们介绍的内容中所使用的引用 都是强引用，这是使用最普遍的引用。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空 间不足，Java 虚拟机宁愿抛出 OutOfMemoryError 错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。

软引用（SoftReference ）

SoftReference 类的一个典型用途就是用于内存敏感的高速缓存。SoftReference 的原理是：在保持对对象的引用时保证在 JVM 报告内存不足情况之前将清除所有的软引用。关键之处在于，垃圾收集器在运行时可能会（也可能不会）释放软可及对象。对象是否被释放取决于垃圾收集器的算法 以及垃圾收集器运行时可用的内存数量。

弱引用（WeakReference ）

WeakReference 类的一个典型用途就是规范化映射（ canonicalized mapping ）。另外，对于那些生存期相对较长而且重新创建的开销也不高的对象来说，弱引用也比较有用。关键之处在于，垃圾收集器运行时如果碰到了弱可及对象，将释放 WeakReference 引用的对象。然而，请注意，垃圾收集器可能要运行多次才能找到并释放弱可及对象。

虚引用（PhantomReference ）

PhantomReference 类只能用于跟踪对被引用对象即将进行的收集。同样，它还能用于执行 pre-mortem 清除操作。PhantomReference 必须与 ReferenceQueue 类一起使用。需要 ReferenceQueue 是因为它能够充当通知机制。当垃圾收集器确定了某个对象是虚可及对象时， PhantomReference 对象就被放在它的 ReferenceQueue 上。将 PhantomReference 对象放在 ReferenceQueue 上也就是一个通知，表明 PhantomReference 对象引用的对象已经结束，可供收集了。这使您能够刚好在对象占用的内存被回收之前采取行动。Reference与 ReferenceQueue 的配合使用。

GC、 Reference 与 ReferenceQueue 的交互

A、 GC无法删除存在强引用的对象的内存。

B、 GC发现一个只有软引用的对象内存，那么：

① SoftReference对象的 referent 域被设置为 null ，从而使该对象不再引用 heap 对象。

② SoftReference引用过的 heap 对象被声明为 finalizable 。

③ 当 heap 对象的 finalize() 方法被运行而且该对象占用的内存被释放， SoftReference 对象就被添加到它的 ReferenceQueue （如果后者存在的话）。

C、 GC发现一个只有弱引用的对象内存，那么：

① WeakReference对象的 referent 域被设置为 null , 从而使该对象不再引用heap 对象。

② WeakReference引用过的 heap 对象被声明为 finalizable 。

③ 当heap 对象的 finalize() 方法被运行而且该对象占用的内存被释放时， WeakReference 对象就被添加到它的 ReferenceQueue （如果后者存在的话）。

D、 GC发现一个只有虚引用的对象内存，那么：

① PhantomReference引用过的 heap 对象被声明为 finalizable 。

② PhantomReference在堆对象被释放之前就被添加到它的 ReferenceQueue 。

值得注意的地方有以下几点：

1、 GC 在一般情况下不会发现软引用的内存对象，只有在内存明显不足的时候才会发现并释放软引用对象的内存。

2、 GC 对弱引用的发现和释放也不是立即的，有时需要重复几次 GC ，才会发现并释放弱引用的内存对象。3、软引用和弱引用在添加到 ReferenceQueue 的时候，其指向真实内存的引用已经被置为空了，相关的内存也已经被释放掉了。而虚引用在添加到 ReferenceQueue 的时候，内存还没有释放，仍然可以对其进行访问。

代码示例

通过以上的介绍，相信您对Java 的引用机制以及几种引用方式的异同已经有了一定了解。光是概念，可能过于抽象，下面我们通过一个例子来演示如何在代码中使用 Reference 机制。

String str = new String( " hello " ); // ①ReferenceQueue String rq = new ReferenceQueue String (); // ②WeakReference String wf = new WeakReference String (str, rq); // ③str = null ; // ④取消"hello"对象的强引用String str1 = wf.get(); // ⑤假如"hello"对象没有被回收，str1引用"hello"对象// 假如"hello"对象没有被回收，rq.poll()返回nullReference ? extends String ref = rq.poll(); // ⑥

在以上代码中，注意⑤⑥两处地方。假如“hello ”对象没有被回收 wf.get() 将返回“ hello ”字符串对象， rq.poll() 返回 null ；而加入“ hello ”对象已经被回收了，那么 wf.get() 返回 null ， rq.poll() 返回 Reference 对象，但是此 Reference 对象中已经没有 str 对象的引用了 ( PhantomReference 则与WeakReference 、 SoftReference 不同 )。

引用机制与复杂数据结构的联合应用

了解了GC 机制、引用机制，并配合上 ReferenceQueue ，我们就可以实现一些防止内存溢出的复杂数据类型。

例如，SoftReference 具有构建 Cache 系统的特质，因此我们可以结合哈希表实现一个简单的缓存系统。这样既能保证能够尽可能多的缓存信息，又可以保证 Java 虚拟机不会因为内存泄露而抛出 OutOfMemoryError 。这种缓存机制特别适合于内存对象生命周期长，且生成内存对象的耗时比较长的情况，例如缓存列表封面图片等。对于一些生命周期较长，但是生成内存对象开销不大的情况，使用WeakReference 能够达到更好的内存管理的效果。

附SoftHashmap 的源码一份，相信看过之后，大家会对 Reference 机制的应用有更深入的理解。

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

1、首先得搞清楚什么叫内存泄露，简单来说就是一个东西放在内存里的时间太长了，当你的程序都跑完了，它还存在那里。这时它是白白的占用了你的内存，累积起来占用的内存越来越多……最后就会导致JVM报错：out of memory。

2、一般情况下，别人如果能指出你的系统（程序）内存溢出，这个人应该还是挺厉害的。通常对于新人来说，喜欢把变量直接定义在class下（此时称之为实例变量，或者成员变量），那么在方法里调用后，这个实例变量是不会被释放的，大量的这样使用就可能会引发内存泄露。

3、把变量定义在方法里，当这个方法执行完毕后内存就得到释放了，这是个好习惯。

4、如果想要看到内存溢出，可以按这样的思路去尝试一下：定义一个静态的实例变量（list或其它集合），然后在一个方法里循环往这个静态变量塞东西，直到这个实例变量撑爆你的jvm内存。很快你就能看到out of memory……

import java.util.ArrayList;

import java.util.List;

public class MemoryTest {

private static List list = new ArrayList();

private static int count = 0;

public static void main(String[] args) throws InterruptedException {

System.out.println("申请前的可用内存 = "+getFreeMemory());

while(true){

list.add(new byte[1024*1024]);//用实例变量申请1M内存，当方法执行完毕时，这个static的变量是不会被释放

count++;

if (count % 100 == 0) {

System.out.println("当前list.size()="+list.size()+",可用内存 = "+getFreeMemory());

Thread.sleep(500);

}

}

}

public static long getFreeMemory() {

return Runtime.getRuntime().freeMemory() / (1024 * 1024);

}

}

如何防止java中的内存泄漏

前些天紧急出版本，发现一个内存泄漏问题，程序每次注销都会有大量的对象没有释放，在

注销登陆成功后，又会重新生成一个相同的对象。这样，在做界面自动化测试的过程中，系统

频繁注销，登陆，再注销。这样如此反复多次，会必然导致java这个进程的内存溢出OutOfMemory。

拿到问题，用JProfile把程序跑起来，查到具体泄漏的对象，然后进行详细的分析。

发现两个地方存在严重的泄漏：

1 某对象在创建，初始化的过程会创建一个线程，这个线程专门处理和计算机串口的通讯。

代码如下：package example;/*** @author zLan1028** TODO To change the template for this generated type comment go to

* Window - Preferences - Java - Code Style - Code Templates*/public class MemoeryTest{

public static void main(String[] args){MemoeryTest test = new MemoeryTest();

test.init();

test = null;

//do other something}

public void init(){thread.start();}

private Thread thread = new BasicThread ();

boolean exit = false;

class BasicThread extends Thread(){List lstData = new LinkedList();

public void run(){while(!exit){synchronized(lstData){if (lstData.isEmpty()){lstData.wait();}writeDataToSerialPort((String)lstData.removeFirst());}}}

咋一看，应该会，这个对象已经没有其它引用存在。其实不然，因为这个对象中创建了一个内部类。

而在java中，内部类会自动获得一个对外部类的对象引用，而在释放test对象时，没有去把它内部创建的线程对象,

所以这个线程对象在程序退出前会一直存在，所以它会一直保持对外部test对象的引用，这样，每创建一个MemoeryTest

对象，都会存在一个线程对象泄漏，而且一个MemoeryTest对象泄漏。这样时非常危险的。

如果只对这个对象进行初始化，而在程序注销时没有对创建的线程资源回收，则这个问题可以避免。

代码如下：在MemoeryTest 对象中增加一个 public void close()方法，在每次释放MemoeryTest 对象时，主动调用close方法释放资源。

名称栏目：java怎么写代码避免内存泄漏,如何避免内存泄漏java
网页URL：http://kswjz.com/article/hdosei.html