java内存管理深入浅出

╰+攻爆jí腚メ 2021-09-10 12:06 214阅读 0赞

[林炳文Evankaka][Evankaka]原创作品。转载请注明出处[http://blog.csdn.net/evankaka][Evankaka]

摘要：本文主要讲解了Java中的内存管理机制、泄露机制及各种数据的存储方式，内存管理是JAVA学习中的一个重点，深入理解它有助于帮助我们加深对JAVA程序的理解

**1.java是如何管理内存的**

为了判断Java中是否有内存泄露，我们首先必须了解Java是如何管理内存的。Java的内存管理就是对象的分配和释放问题。在Java中，内存的分配是由程序完成的，而内存的释放是由垃圾收集器(Garbage Collection，GC)完成的，程序员不需要通过调用函数来释放内存，但它只能回收无用并且不再被其它对象引用的那些对象所占用的空间。

Java的内存垃圾回收机制是从程序的主要运行对象开始检查引用链，当遍历一遍后发现没有被引用的孤立对象就作为垃圾回收。GC为了能够正确释放对象，必须监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等，GC都需要进行监控。监视对象状态是为了更加准确地、及时地释放对象，而释放对象的根本原则就是该对象不再被引用。

在Java中，这些无用的对象都由GC负责回收，因此程序员不需要考虑这部分的内存泄露。虽然，我们有几个函数可以访问GC，例如运行GC的函数System.gc()，但是根据Java语言规范定义，该函数不保证JVM的垃圾收集器一定会执行。因为不同的JVM实现者可能使用不同的算法管理GC。通常GC的线程的优先级别较低。JVM调用GC的策略也有很多种，有的是内存使用到达一定程度时，GC才开始工作，也有定时执行的，有的是平缓执行GC，有的是中断式执行GC。但通常来说，我们不需要关心这些。

为了更好理解GC的工作原理，我们可以将对象考虑为有向图的顶点，将引用关系考虑为图的有向边，有向边从引用者指向被引对象。另外，每个线程对象可以作为一个图的起始顶点，例如大多程序从main进程开始执行，那么该图就是以main进程顶点开始的一棵根树。在这个有向图中，根顶点可达的对象都是有效对象，GC将不回收这些对象。如果某个对象 (连通子图)与这个根顶点不可达(注意，该图为有向图)，那么我们认为这个(这些)对象不再被引用，可以被GC回收。

以下，我们举一个例子说明如何用有向图表示内存管理。对于程序的每一个时刻，我们都有一个有向图表示JVM的内存分配情况。以下右图，就是左边程序运行到第6行的示意图。

![20150326195126368][]

Java使用有向图的方式进行内存管理，可以消除引用循环的问题，例如有三个对象，相互引用，只要它们和根进程不可达的，那么GC也是可以回收它们的。这种方式的优点是管理内存的精度很高，但是效率较低。另外一种常用的内存管理技术是使用计数器，例如COM模型采用计数器方式管理构件，它与有向图相比，精度行低(很难处理循环引用的问题)，但执行效率很高。

**2.什么叫java的内存泄露**

导致内存泄漏主要的原因是，先前申请了内存空间而忘记了释放。如果程序中存在对无用对象的引用，那么这些对象就会驻留内存，消耗内存，因为无法让垃圾回收器GC验证这些对象是否不再需要。如果存在对象的引用，这个对象就被定义为"有效的活动"，同时不会被释放。要确定对象所占内存将被回收，我们就要务必确认该对象不再会被使用。典型的做法就是把对象数据成员设为null或者从集合中移除该对象。但当局部变量不需要时，不需明显的设为null，因为一个方法执行完毕时，这些引用会自动被清理。

在Java中，内存泄漏就是存在一些被分配的对象，这些对象有下面两个特点，首先，这些对象是有被引用的，即在有向树形图中，存在树枝通路可以与其相连；其次，这些对象是无用的，即程序以后不会再使用这些对象。如果对象满足这两个条件，这些对象就可以判定为Java中的内存泄漏，这些对象不会被GC所回收，然而它却占用内存。

下面，我们就可以描述什么是内存泄漏。在Java中，内存泄漏就是存在一些被分配的对象，这些对象有下面两个特点，首先，这些对象是可达的，即在有向图中，存在通路可以与其相连；其次，这些对象是无用的，即程序以后不会再使用这些对象。如果对象满足这两个条件，这些对象就可以判定为Java中的内存泄漏，这些对象不会被GC所回收，然而它却占用内存。

在C++中，内存泄漏的范围更大一些。有些对象被分配了内存空间，然后却不可达，由于C++中没有GC，这些内存将永远收不回来。在Java中，这些不可达的对象都由GC负责回收，因此程序员不需要考虑这部分的内存泄露。

通过分析，我们得知，对于C++，程序员需要自己管理边和顶点，而对于Java程序员只需要管理边就可以了(不需要管理顶点的释放)。通过这种方式，Java提高了编程的效率。

![20150326195536904][]

对于程序员来说，GC基本是透明的，不可见的。虽然，我们只有几个函数可以访问GC，例如运行GC的函数System.gc()，但是根据Java语言规范定义， 该函数不保证JVM的垃圾收集器一定会执行。因为，不同的JVM实现者可能使用不同的算法管理GC。通常，GC的线程的优先级别较低。JVM调用GC的策略也有很多种，有的是内存使用到达一定程度时，GC才开始工作，也有定时执行的，有的是平缓执行GC，有的是中断式执行GC。但通常来说，我们不需要关心这些。除非在一些特定的场合，GC的执行影响应用程序的性能，例如对于基于Web的实时系统，如网络游戏等，用户不希望GC突然中断应用程序执行而进行垃圾回收，那么我们需要调整GC的参数，让GC能够通过平缓的方式释放内存，例如将垃圾回收分解为一系列的小步骤执行，Sun提供的HotSpot JVM就支持这一特性。

下面给出了一个简单的内存泄露的例子。在这个例子中，我们循环申请Object对象，并将所申请的对象放入一个Vector中，如果我们仅仅释放引用本身，那么Vector仍然引用该对象，所以这个对象对GC来说是不可回收的。因此，如果对象加入到Vector后，还必须从Vector中删除，最简单的方法就是将Vector对象设置为null。

<table> 
 <tbody> 
  <tr> 
   <td><pre>Vector v=new Vector(10);
for (int i=1;i&lt;100; i++)
{
	Object o=new Object();
	v.add(o);
	o=null;	
}</pre></td> 
  </tr> 
 </tbody> 
</table>

//此时，所有的Object对象都没有被释放，因为变量v引用这些对象。

再引用另一个例子来说明Java的内存泄漏。假设有一个日志类Logger，其提供一个静态的log(String msg)，任何其它类都可以调用Logger.Log(message)来将message的内容记录到系统的日志文件中。        Logger类有一个类型为HashMap的静态变量temp，每次在执行log(message)的时候，都首先将message的值写入temp中(以当前线程+当前时间为键)，在退出之前再从temp中将以当前线程和当前时间为键的条目删除。注意，这里当前时间是不断变化的，所以log在退出之前执行删除条目的操作并不能删除执行之初写入的条目。这样，任何一个作为参数传给log的字符串最终由于被Logger的静态变量temp引用，而无法得到回收，这种对象保持就是我们所说的Java内存泄漏。 总的来说，内存管理中的内存泄漏产生的主要原因：保留下来却永远不再使用的对象引用。

**3.JVM的内存区域组成**

程序运行时，我们最好对数据保存到什么地方做到心中有数。特别要注意的是内存的分配。有六个地方都可以保存数据：  
(1) 寄存器。这是最快的保存区域，因为它位于和其他所有保存方式不同的地方：处理器内部。然而，寄存器的数量十分有限，所以寄存器是根据需要由编译器分配。我们对此没有直接的控制权，也不可能在自己的程序里找到寄存器存在的任何踪迹。  
(2) 堆栈。驻留于常规RAM（随机访问存储器）区域，但可通过它的“堆栈指针”获得处理的直接支持。堆栈指针若向下移，会创建新的内存；若向上移，则会释放那些内存。这是一种特别快、特别有效的数据保存方式，仅次于寄存器。创建程序时，Java编译器必须准确地知道堆栈内保存的所有数据的“长度”以及“存在时间”。这是由于它必须生成相应的代码，以便向上和向下移动指针。这一限制无疑影响了程序的灵活性，所以尽管有些Java数据要保存在堆栈里——特别是对象句柄，但Java对象并不放到其中。  
(3) 堆。一种常规用途的内存池（也在RAM区域），其中保存了Java对象。和堆栈不同，“内存堆”或“堆”（Heap）最吸引人的地方在于编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间。因此，用堆保存数据时会得到更大的灵活性。要求创建一个对象时，只需用new命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存。当然，为达到这种灵活性，必然会付出一定的代价：在堆里分配存储空间时会花掉更长的时间！  
(4) 静态存储。这儿的“静态”（Static）是指“位于固定位置”（尽管也在RAM里）。程序运行期间，静态存储的数据将随时等候调用。可用static关键字指出一个对象的特定元素是静态的。但Java对象本身永远都不会置入静态存储空间。  
(5) 常数存储。常数值通常直接置于程序代码内部。这样做是安全的，因为它们永远都不会改变。有的常数需要严格地保护，所以可考虑将它们置入只读存储器（ROM）。  
(6) 非RAM存储。若数据完全独立于一个程序之外，则程序不运行时仍可存在，并在程序的控制范围之外。其中两个最主要的例子便是“流式对象”和“固定对象”。对于流式对象，对象会变成字节流，通常会发给另一台机器。而对于固定对象，对象保存在磁盘中。即使程序中止运行，它们仍可保持自己的状态不变。对于这些类型的数据存储，一个特别有用的技巧就是它们能存在于其他媒体中。一旦需要，甚至能将它们恢复成普通的、基于RAM的对象。Java 1.1提供了对Lightweight persistence的支持。未来的版本甚至可能提供更完整的方案。

**4.java中数据在内存中是如何存储的**

a)基本数据类型

java的基本数据类型共有8种，即int,short,long,byte,float,double,boolean,char(注意，并没有String的基本类型 )。这种类型的定义是通过诸如int a = 3；long b = 255L；的形式来定义的。如int a = 3；这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。

另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。比如：  
我们同时定义：（注意，这里指在同一函数中定义的基本类型变量）

int a=3;  
int b=3;

编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b = 3；在创建完b这个引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。

定义完a与b的值后，再令a = 4；那么，b不会等于4，还是等于3。在编译器内部，遇到时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。

b)对象

在java中，创建一个对象包括对象的声明和实例化两步，下面用一个例题来说明对象的内存模型。假设有类Rectangle定义如下：

public class Rectangle {
        double width;
        double height;
        public Rectangle( double w, double h){
        w = width;
        h = height;
        }
        }

c)创建多个不同的对象实例

一个类通过使用new运算符可以创建多个不同的对象实例，这些对象实例将在堆中被分配不同的内存空间，改变其中一个对象的状态不会影响其他对象的状态。例如：

Rectangle r1= new Rectangle(3,5);
       Rectangle r2= new Rectangle(4,6);

此时，将在堆内存中分别为两个对象的成员变量 width 、 height 分配内存空间，两个对象在堆内存中占据的空间是互不相同的。如果有：

Rectangle r1=new Rectangle(3,5);
       Rectangle r2=r1;

则在堆内存中只创建了一个对象实例，在栈内存中创建了两个对象引用，两个对象引用同时指向一个对象实例。

d)包装类

基本类型都有对应的包装类：如int对应Integer类，double对应Double类等，基本类型的定义都是直接在栈中，如果用包装类来创建对象，就和普通对象一样了。例如：int i=0；i直接存储在栈中。Integer i（i此时是对象）= new Integer(5)；这样，i对象数据存储在堆中，i的引用存储在栈中，通过栈中的引用来操作对象。

e)String

String是一个特殊的包装类数据。可以用以下两种方式创建：String str = new String(“abc”)；String str = “abc”;  
第一种创建方式，和普通对象的的创建过程一样；  
第二种创建方式，java内部将此语句转化为以下几个步骤：  
(1)先定义一个名为str的对String类的对象引用变量：String str；  
(2)在栈中查找有没有存放值为”abc”的地址，如果没有，则开辟一个存放字面值为”abc”  
地址，接着创建一个新的String类的对象o，并将o的字符串值指向这个地址，而且在栈  
这个地址旁边记下这个引用的对象o。如果已经有了值为”abc”的地址，则查找对象o，并  
回o的地址。  
(3)将str指向对象o的地址。  
值得注意的是，一般String类中字符串值都是直接存值的。但像String str = “abc”；这种  
合下，其字符串值却是保存了一个指向存在栈中数据的引用。  
为了更好地说明这个问题，我们可以通过以下的几个代码进行验证。

String str1="abc"；
       String str2="abc"；
       System.out.println(s1==s2)；//true

注意，这里并不用 str1.equals(str2)；的方式，因为这将比较两个字符串的值是否相等。==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返回真值。而我们在这里要看的是，str1与str2是否都指向了同一个对象。  
我们再接着看以下的代码。

String str1= new String("abc")；
       String str2= "abc"；
       System.out.println(str1==str2)；//false

创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。  
以上两段代码说明，只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。

f)数组

当定义一个数组，int x\[\]；或int\[\] x；时，在栈内存中创建一个数组引用，通过该引用（即数组名）来引用数组。x=new int\[3\]；将在堆内存中分配3个保存 int型数据的空间，堆内存的首地址放到栈内存中，每个数组元素被初始化为0。

g)静态变量

用static的修饰的变量和方法，实际上是指定了这些变量和方法在内存中的”固定位置”－static storage，可以理解为所有实例对象共有的内存空间。static变量有点类似于C中的全局变量的概念；静态表示的是内存的共享，就是它的每一个实例都指向同一个内存地址。把static拿来，就是告诉JVM它是静态的，它的引用（含间接引用）都是指向同一个位置，在那个地方，你把它改了，它就不会变成原样，你把它清理了，它就不会回来了。

那静态变量与方法是在什么时候初始化的呢？对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创建实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的创建，不再次进行初始化。

我们常可看到类似以下的例子来说明这个问题：

class Student{ 
       static int numberOfStudents =0;
       Student()
       { 
       numberOfStudents ++;
       }
       }

每一次创建一个新的Student实例时,成员numberOfStudents都会不断的递增,并且所有的Student实例都访问同一个numberOfStudents变量,实际上intnumberOfStudents变量在内存中只存储在一个位置上。

**5.java的内存管理实例**

Java程序的多个部分(方法，变量，对象)驻留在内存中以下两个位置：即堆和栈，现在我们只关心三类事物：实例变量，局部变量和对象：  
实例变量和对象驻留在堆上  
局部变量驻留在栈上  
让我们查看一个 java 程序，看看他的各部分如何创建并且映射到栈和堆中：

public class Dog {
        Collar c;
        String name;
        //1.main()方法位于栈上
        public static void main(String[] args) {
        //2.在栈上创建引用变量d,但Dog对象尚未存在
        Dog d;
        //3.创建新的Dog对象，并将其赋予d引用变量
        d = new Dog();
        //4.将引用变量的一个副本传递给go()方法
        d.go(d);
        }
        //5.将go()方法置于栈上，并将dog参数作为局部变量
        void go(Dog dog){
        //6.在堆上创建新的Collar对象，并将其赋予Dog的实例变量
        c = new Collar();
        }
        //7.将setName()添加到栈上，并将dogName参数作为其局部变量
        void setName(String dogName){
        //8.name的实例对象也引用String对象
        name =dogName;
        }
        //9.程序执行完成后，setName()将会完成并从栈中清除，此时，局部变量dogName也会消失，尽管它所引用的String仍在堆上
        }

**6. 垃圾回收机制**

问题一：什么叫垃圾回收机制？  
垃圾回收是一种动态存储管理技术，它自动地释放不再被程序引用的对象，按照特定的垃圾收集算法来实现资源自动回收的功能。当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用，以免造成内存泄露。

问题二：java的垃圾回收有什么特点？  
jAVA语言不允许程序员直接控制内存空间的使用。内存空间的分配和回收都是由JRE负责在后台自动进行的，尤其是无用内存空间的回收操作(garbagecollection,也称垃圾回收)，只能由运行环境提供的一个超级线程进行监测和控制。

问题三：垃圾回收器什么时候会运行？  
一般是在CPU空闲或空间不足时自动进行垃圾回收，而程序员无法精确控制垃圾回收的时机和顺序等。、

问题四：什么样的对象符合垃圾回收条件？  
当没有任何获得线程能访问一个对象时，该对象就符合垃圾回收条件。

问题五：垃圾回收器是怎样工作的？  
垃圾回收器如发现一个对象不能被任何活线程访问时，他将认为该对象符合删除条件，就将其加入回收队列，但不是立即销毁对象，何时销毁并释放内存是无法预知的。垃圾回收不能强制执行，然而java提供了一些方法（如：System.gc()方法），允许你请求JVM执行垃圾回收，而不是要求，虚拟机会尽其所能满足请求，但是不能保证JVM从内存中删除所有不用的对象。

问题六：一个java程序能够耗尽内存吗？  
可以。垃圾收集系统尝试在对象不被使用时把他们从内存中删除。然而，如果保持太多活的对象，系统则可能会耗尽内存。垃圾回收器不能保证有足够的内存，只能保证可用内存尽可能的得到高效的管理。

问题七：如何显示的使对象符合垃圾回收条件？  
(1)空引用：当对象没有对他可到达引用时，他就符合垃圾回收的条件。也就是说如果没有对他的引用，删除对象的引用就可以达到目的，因此我们可以把引用变量设置为null，来符合垃圾回收的条件。

StringBuffer sb = new StringBuffer("hello");
       System.out.println(sb);
       sb= null;

(2)重新为引用变量赋值：可以通过设置引用变量引用另一个对象来解除该引用变量与一个对象间的引用关系。  
StringBuffer sb1 = new StringBuffer(“hello”);  
StringBuffer sb2 = new StringBuffer(“goodbye”);  
System.out.println(sb1);  
sb1=sb2;//此时”hello”符合回收条件  
(3)方法内创建的对象：所创建的局部变量仅在该方法的作用期间内存在。一旦该方法返回，在这个方法内创建的对象就符合垃圾收集条件。有一种明显的例外情况，就是方法的返回对象。

public static void main(String[] args) { 
       Date d = getDate();
       System.out.println("d="+d);
       }
       private static Date getDate() { 
       Date d2 = new Date();
       StringBuffer now = new StringBuffer(d2.toString());
       System.out.println(now);
       return d2;
       }

(4)隔离引用：这种情况中，被回收的对象仍具有引用，这种情况称作隔离岛。若存在这两个实例，他们互相引用，并且这两个对象的所有其他引用都删除，其他任何线程无法访问这两个对象中的任意一个。也可以符合垃圾回收条件。

public class Island { 
       Island i;
       public static void main(String[] args) { 
       Island i2 = new Island();
       Island i3 = new Island();
       Island i4 = new Island();
       i2. i =i3;
       i3. i =i4;
       i4. i =i2;
       i2= null;
       i3= null;
       i4= null;
       }
       }

**7.final问题**

final使得被修饰的变量”不变”，但是由于对象型变量的本质是”引用”，使得”不变”也有了两种含义：引用本身的不变和引用指向的对象不变。  
引用本身的不变：

final StringBuffer a= new StringBuffer("immutable");
       final StringBuffer b= new StringBuffer("not immutable");
       a=b;//编译期错误
       final StringBuffer a=new StringBuffer("immutable");
       final StringBuffer b=new StringBuffer("not immutable");

a=b;//编译期错误

引用指向的对象不变：

final StringBuffer a= new StringBuffer("immutable");
       a.append（"broken!");//编译通过
       final StringBuffer a=new StringBuffer("immutable");
       a.append("broken!");//编译通过

可见，final只对引用的”值”(也即它所指向的那个对象的内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。这很类似==操作符：==操作符只负责引用的”值”相等，至于这个地址所指向的对象内容是否相等，==操作符是不管的。在举一个例子：

class Name{
    	private String firstname;
    	private String lastname;
    	public String getFirstname() {
    		return firstname;
    	}
    	public void setFirstname(String firstname) {
    		this.firstname = firstname;
    	}
    	public String getLastname() {
    		return lastname;
    	}
    	public void setLastname(String lastname) {
    		this.lastname = lastname;
    	}
    	
    }
    public class learning1 {
    
    	public static void main(String[] args) {
        final Name name=new Name();
        name.setFirstname("lin");
        name.setLastname("bingwen");
        System.out.println("firstname:"+name.getFirstname()+" lastname:"+name.getLastname());
        name.setFirstname("evan");
        name.setLastname("kaka");
        System.out.println("firstname:"+name.getFirstname()+" lastname:"+name.getLastname());
    	}
    
    }

结果：

**firstname:lin lastname:bingwen  
firstname:evan lastname:kaka**

理解final问题有很重要的含义。许多程序漏洞都基于此—-final只能保证引用永远指向固定对象，不能保证那个对象的状态不变。在多线程的操作中，一个对象会被多个线程共享或修改，一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final，意图使得它”永远不变”。其实那是徒劳的.final还有一个值得注意的地方，  
先看以下示例程序：

class Something { 
       final int i ;
       public void doSomething() { 
       System. out .println( "i = " + i );
       }
       }
       class Something { 
       final int i;
       public void doSomething() { 
       System.out.println("i = " + i);
       }
       }

对于类变量，java虚拟机会自动进行初始化。如果给出了初始值，则初始化为该初始值。如果没有给出，则把它初始化为该类型变量的默认初始值。但是对于用final修饰的类变量，虚拟机不会为其赋予初值，必须在constructor(构造器)结束之前被赋予一个明确的值。可以修改为”final int i = 0;”。

**8.如何把程序写得更健壮**

(1)尽早释放无用对象的引用。  
好的办法是使用临时变量的时候，让引用变量在退出活动域后，自动设置为null，暗示垃圾收集器来收集该对象，防止发生内存泄露。对于仍然有指针指向的实例，jvm就不会回收该资源,因为垃圾回收会将值为null的对象作为垃圾，提高GC回收机制效率；

(2)定义字符串应该尽量使用String str=”hello”;的形式，避免使用String str = new String(“hello”);的形式。因为要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做：

public class Demo { 
       private String s;
       public Demo() { 
       s = "Initial Value";
       }
       }
        
       public class Demo { 
       private String s;
       ...
       public Demo { 
       s = "Initial Value";
       }
       ...
       }
       而非
       s =  new  String("Initial Value");
       s = new String("Initial Value");

后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。

(3)我们的程序里不可避免大量使用字符串处理，避免使用String，应大量使用StringBuffer，因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象，请看下列代码；

String s = "Hello";
       s = s + " world!";
       String s = "Hello";
       s = s + " world!";

在这段代码中，s原先指向一个String对象，内容是”Hello”，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个String对象，内容为”Hello world!”，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。

通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。

(4)尽量少用静态变量，因为静态变量是全局的，GC不会回收的；

(5)尽量避免在类的构造函数里创建、初始化大量的对象，防止在调用其自身类的构造器时造成不必要的内存资源浪费，尤其是大对象，JVM会突然需要大量内存，这时必然会触发GC优化系统内存环境；显示的声明数组空间，而且申请数量还极大。  
以下是初始化不同类型的对象需要消耗的时间：

<table style="border-spacing:0px; width:630px; color:rgb(0,0,0); font-family:'Microsoft Yahei','Microsoft Henghei','hiragino sans gb',Helvetica,Tahoma,'Lucida Grande',Georgia,Verdana; font-size:13px; letter-spacing:1px; line-height:22px"> 
 <tbody> 
  <tr> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">运算操作</p></td> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">示例</p></td> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">标准化时间</p></td> 
  </tr> 
  <tr> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">本地赋值</p></td> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">i = n</p></td> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">1.0</p></td> 
  </tr> 
  <tr> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">实例赋值</p></td> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">this.i = n</p></td> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">1.2</p></td> 
  </tr> 
  <tr> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">方法调用</p></td> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">Funct()</p></td> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">5.9</p></td> 
  </tr> 
  <tr> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">新建对象</p></td> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">New Object()</p></td> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">980</p></td> 
  </tr> 
  <tr> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">新建数组</p></td> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">New int[10]</p></td> 
   <td style="padding:3px 6px; margin:0px; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:rgb(211,218,229); border-right-width:1px; border-right-style:solid; border-right-color:rgb(211,218,229)"><p style="padding-top:0px; padding-bottom:0px; margin-top:0px; margin-bottom:15px">3100</p></td> 
  </tr> 
 </tbody> 
</table>

从表中可以看出，新建一个对象需要980个单位的时间，是本地赋值时间的980倍，是方法调用时间的166倍，而新建一个数组所花费的时间就更多了。

(6)尽量在合适的场景下使用对象池技术以提高系统性能，缩减缩减开销，但是要注意对象池的尺寸不宜过大，及时清除无效对象释放内存资源，综合考虑应用运行环境的内存资源限制，避免过高估计运行环境所提供内存资源的数量。

(7)大集合对象拥有大数据量的业务对象的时候，可以考虑分块进行处理，然后解决一块释放一块的策略。

(8)不要在经常调用的方法中创建对象，尤其是忌讳在循环中创建对象。可以适当的使用hashtable，vector创建一组对象容器，然后从容器中去取那些对象，而不用每次new之后又丢弃。

(9)一般都是发生在开启大型文件或跟数据库一次拿了太多的数据，造成Out Of Memory Error的状况，这时就大概要计算一下数据量的最大值是多少，并且设定所需最小及最大的内存空间值。

(10)尽量少用finalize函数，因为finalize()会加大GC的工作量，而GC相当于耗费系统的计算能力。

(11)不要过滥使用哈希表，有一定开发经验的开发人员经常会使用hash表（hash表在JDK中的一个实现就是HashMap）来缓存一些数据，从而提高系统的运行速度。比如使用HashMap缓存一些物料信息、人员信息等基础资料，这在提高系统速度的同时也加大了系统的内存占用，特别是当缓存的资料比较多的时候。其实我们可以使用操作系统中的缓存的概念来解决这个问题，也就是给被缓存的分配一个一定大小的缓存容器，按照一定的算法淘汰不需要继续缓存的对象，这样一方面会因为进行了对象缓存而提高了系统的运行效率，同时由于缓存容器不是无限制扩大，从而也减少了系统的内存占用。现在有很多开源的缓存实现项目，比如ehcache、oscache等，这些项目都实现了FIFO 、MRU等常见的缓存算法。

[林炳文Evankaka][Evankaka]原创作品。转载请注明出处 [http://blog.csdn.net/evankaka][Evankaka]

[Evankaka]: http://blog.csdn.net/evankaka
[20150326195126368]: /images/20210811/02ab92f53c9b4def9812cdb03fcbfcfd.png
[20150326195536904]: /images/20210811/60b627f807244ad79b68662e2b210be3.png