Java的内存机制

                                                                       Java的内存机制

Java内存介绍：        

         Java 把内存划分成两种：一种是栈内存，另一种是堆内存。在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配，当在一段代码块定义一个变量时，Java 就在栈中为这个变量分配内存空间，当超过变量的作用域后(比如，在函数A中调用函数B，在函数B中定义变量a，变量a的作用域只是函数B，在函数B运行完以后，变量a会自动被销毁。分配给它的内存会被回收)，Java 会自动释放掉为该变量分配的内存空间，该内存空间可以立即被另作它用。

            堆内存用来存放由 new 创建的对象和数组，在堆中分配的内存，由 Java 虚拟机的自动垃圾回收器来管理。在堆中产生了一个数组或者对象之后，还可以在栈中定义一个特殊的变量，让栈中的这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量(变量名)，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或者对象，引用变量就相当于是为数组或者对象 起的一个名称。引用变量是普通的变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配，即使程序运行到使用 new 产生数组或者对象的语句所在的代码块之外，数组和对象本身占据的内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能再被使用，但仍然占据内存空间不放，在随后的一个不确定的时间被垃圾回收器收走（释放掉），而在c++中则要人为的调用对象的析构函数。

 

这也是Java比较占内存的原因，实际上，栈中的变量指向堆内存中的变量，这就是 Java 中的指针！

      例如定义一个二维的数组，它的内存分配如下图：

 

内存分配策略：
         按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的。Java实际在编译时不会分配内存，统一在运行时由JVM进行分配，以下只是为了理解方便。
         静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.这种分配策略要求程序代 码中不允许有可变数据结构(比如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们都会导致编译程序无法计算准确的存储空间需求。   分配的是全局数据域和全局代码区。

        动态存储分配也可称为栈式存储分配，要求在过程的入口处必须知道所有的存储要求,是由一个类似于堆栈的运行栈来实现的.和静态存储分配相反,在栈式存储方案中,程序对数据区的需求在编译时是完全未知的,只有到运行的时候才能够知道,但是规定在运行中进入一个程序模块时,必须知道该程序模块所需的数据区大小才能够为其分配内存.和我们在数据结 构所熟知的栈一样,栈式存储分配按照先进后出的原则进行分配。                     运行时向栈中插入运行时产生数据（如程序运算产生的结果或为一个即将要调用的程序模块分配数据区时）

        堆式存储分配则专门负责在编译时 或运行时模块入口处都无法确定存储要求的数据结构的内存分配,比如可变长度串和对象实例.堆由大片的可利用块或空闲块组成,堆中的内存可以按照任意顺序分配和释放.             为new关键字创建的对象或数组分配内存

 

理解：         从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的（对像在没实例化是是不知道大小的，只能把对象名存入栈），栈主要是用来执行程序的。

         在编程中，所有的方法调用都是通过栈来进行的,所有的局部变量,形式参数都是从栈中分配内存空间的。实际上也不是什么分配,只 是从栈顶向上用就行,就好像工厂中的传送带(conveyor belt)一样,Stack Pointer会自动指引你到放东西的位置,你所要做的只是把东西放下来就行.退出函数的时候，修改栈指针就可以把栈中的内容销毁.这样的模式速度最快, 当然要用来运行程序了.需要注意的是,在分配的时候,比如为一个即将要调用的程序模块分配数据区时,应事先知道这个数据区的大小,也就说是虽然分配是在程 序运行时进行的,但是分配的大小多少是确定的,不变的,而这个"大小多少"是在编译时确定的,不是在运行时.

          堆是应用程序在运行的时候请求操作系统分配给自己内存，由于从操作系统管理的内存分配,所以在分配和销毁时都要占用时间，因此用堆的效率非常低. 但是堆的优点在于,编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间,因此,用堆保存数据时会得到更大的灵活性。事 实上,面向对象的多态性,堆内存分配是必不可少的,因为多态变量所需的存储空间只有在运行时创建了对象之后才能确定，要求创建一个对象时，只 需用 new命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存.当然，为达到这种灵活性，必然会付出一定的代价:在堆里分配存储空间时会花 掉更长的时间！这也正是导致我们刚才所说的效率低的原因,。

 

java中重要的内存区域（全局数据域和全局代码区是针对编译时而言，JVM有自己内存的划分）：

1.栈内存空间：由编译器自动分配和释放，在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配，操作方式类似于数据结构中等的栈。

2.堆内存空间：在一般由程序员分配（new），程序结束是有GC回收。而在c++中要程序员手动释放

3.全局数据域：保存static类型属性

4.全局代码区：保存所有方法的定义

 

总结：
           栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。
        Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和 multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事 先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较 慢。
        栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一 些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。

 

ps1:       栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：
       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=4；那么编译器 会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。要注意这 种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的（它们是栈中值指向的堆的首地址相同），因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。

 

 

 d==c  true;         e==d   false

         对于e,d,c而言Java不能对栈的右边地址进行直接操作，从而控制引用指向的对象。只能通过左边的引用来对操作堆中的对象操作（我们就把这看作是Java的指针），而在C++中你可一直接定义一个指针变量它的值就是这些首地址，你可一直接将地址++或--的运算控制指针指向的对象是哪一个，这样做效率更高但不安全。

        对于b,a而言你根本不知到3和4在栈中的地址，你只能通过引用a和b对这个值的大小进行操作。而在c++中因为中你可以用&a,&b取到3，和4的地址。

ps2:当你创建一个数组时int类型的默认是0，double默认是0.0，String默认是null,boolean默认是false;

 

ps3:Java中的clone（）和 =

=用于基本数据类型是将值直接赋给该引用，而对于对象是将对象在堆的首地址赋给该引用

clone是类才有的方法且必须实现Cloneable接口才能调用，Java提供一种叫浅拷贝（shallow copy）的默认方式实现clone。属于浅克隆.

浅克隆的效果相当于“=”一样，所以克隆对象的基本数据类型不会随克隆后对象的类型改变而改变，而对象里的引用数据类型包括方法都会随隆后对象的改变而改变.

类重写clone()方法需要实现Cloneable接口，再进行重写，这样可以实现深克隆。String没有克隆方法的原因是你写的类不在ava.lang.String包中，而clone()在object中定义的是受保护的方法。

 

ps4:Java中的==和equals区别

1.     ==可用于基本类型和引用类型：当用于基本类型时候，是比较值是否相同；当用于引用类型的时候，是比较对象在堆区的首地址是否相同。对于Java自带的8中基本类型是直接比较值,String不是基本类型，但通过=赋值的是直接比较值，因为String太过常用，所以设计的时候采用了享元模式，即每当生成一个新的内容字符串是，他们都将被添加到一个共享池中，当第二次再次生成同样的内容的字符串时，就共享此对象而不是创建一个新的对象，但只适用于通过=赋值的String

2.     对于String a = “a”; Integer b = 1;这种类型的特有对象创建方式，==的时候值是相同的（类似与基本类型），而String a = new String("a") ;Interger b = new Interger(b);是不同的（类似与引用类型）,后者创建了两个String对象。

 如果是String f = new String("123");

f 首地址——>new String("123")    f是一个String对象（引用对象），123是一个String对象

3.      基本类型没有equals方法，String（重写了equal方法）比较值其余也是比较地址

4.      一个类如果没有定义equals方法，它将默认继承Object中的equals方法，返回值与==方法相同。

  

 

深入探讨equals：

===================
转自硅谷动力

equals方法的重要性毋须多言,只要你想比较两个对象是不是同一对象,你就应该实现equals方法,让对象用你认为相等的条件来进行比较.

下面的内容只是API的规范,没有什么太高深的意义,但我之所以最先把它列在这儿,是因为这些规范在事实中并不是真正能保证得到实现.

1.对于任何引用类型, o.equals(o) == true成立.

2.如果 o.equals(o1) == true 成立,那么o1.equals(o)==true也一定要成立.

3.如果 o.equals(o1) == true 成立且 o.equals(o2) == true 成立,那么

o1.equals(o2) == true 也成立.

4.如果第一次调用o.equals(o1) == true成立，在o和o1没有改变的情况下以后的任何次调用都成立.

5.o.equals(null) == true 任何时间都不成立.

以上几条规则并不是最完整的表述,详细的请参见API文档.对于Object类,它提供了一个最最严密的实现,那就是只有是同一对象时,equals方法才返回true,这个实现严密得已经没有什么实际的意义, 所以在具体子类(相对于Object来说)中,如果我们要进行对象的值比较,就必须实现自己的equals方法.先来看一下以下这段程序:

public boolean equals(Object obj)

{

if (obj == null) return false;

if (!(obj instanceof FieldPosition))

return false;

FieldPosition other = (FieldPosition) obj;

if (attribute == null) {

if (other.attribute != null) {

return false;

}

}

else if (!attribute.equals(other.attribute)) {

return false;

}

return (beginIndex == other.beginIndex

& endIndex == other.endIndex

&& field == other.field);

}

这是JDK中java.text.FieldPosition的标准实现,似乎没有什么可说的. 我信相大多数或绝大多数程序员认为,这是正确的合法的equals实现.毕竟它是JDK的API实现啊. 还是让我们以事实来说话吧:

package debug

;import java.text.*;

public class Test {

public static void main(String[] args) {

FieldPosition fp = new FieldPosition(10);

FieldPosition fp1 = new MyTest(10);

System.out.println(fp.equals(fp1));

System.out.println(fp1.equals(fp));

}

}

class MyTest extends FieldPosition{

int x = 10;

public MyTest(int x){

super(x);

this.x = x;

}

public boolean equals(Object o){

if(o==null) return false;

if(!(o instanceof MyTest )) return false;

return ((MyTest)o).x == this.x;

}

}

运行一下看看会打印出什么:

System.out.println(fp.equals(fp1));打印true

System.out.println(fp1.equals(fp));打印flase

两个对象,出现了不对称的equals算法.问题出在哪里(脑筋急转弯：当然出在JDK实现的BUG)?我相信有太多的程序员(除了那些根本不知道实现 equals方法的程序员外)在实现equals方法时都用过instanceof运行符来进行短路优化的，实事求是地说很长一段时间我也这么用过。

太多的教程，文档都给了我们这样的误导。而有些稍有了解的程序员可能知道这样的优化可能有些不对但找不出问题的关键。另外一种极端是知道这个技术缺陷的骨 灰级专家就提议不要这样应用。我们知道，"通常"要对两个对象进行比较，那么它们"应该"是同一类型。所以首先利用instanceof运算符进行短路优 化，如果被比较的对象不和当前对象是同一类型则不用比较返回false。

但事实上，如果该类有子类，如果子类  instanceof 父类，始终返回true,这时肯定不会发生短路优化，要进一步比较，下面的比较有可能出现多种情况，一种是不能造型成父类而抛出异常，另一种是父类的private 成员没有被子类继承而不能进行比较，还有就是形成上面这种不对称比较。可能会出现太多的情况。

那么，是不是就不能用instanceof运算符来进行优化？答案是否定的，JDK中仍然有很多实现是正确的，如果一个class是final的，明知它不可能有子类，为什么不用 instanceof来优化呢？

那么对于非final类，如何进行类型的quick check呢？

if(obj.getClass() != XXXClass.class) return false;

用被比较对象的class对象和当前对象的class比较，看起来是没有问题，但是，如果这个类的子类没有重新实现equals方法，那么子类在比较的时候，obj.getClass() 肯定不等于XXXCalss.class, 也就是子类的equals将无效，所以

if(obj.getClass() != this.getClass()) return false;

才是正确的比较。另外一个quick check是if(this==obj) return true;

是否equals方法比较的两个对象一定是要同一类型？上面我用了"通常"，这也是绝大多数程序员的愿望，但是有些特殊的情况，我们可以进行不同类型的比 较，这并不违反规范。但这种特殊情况是非常罕见的，一个不恰当的例子是，Integer类的equals可以和Sort做比较，比较它们的value是不 是同一数学值。（事实上JDK的API中并没有这样做，所以我才说是不恰当的例子）在完成quick check以后，我们就要真正实现你认为的“相等”。对于如果实现对象相等，没有太高的要求，比如你自己实现的“人”类，你可以认为只要name相同即认 为它们是相等的，其它的sex, ago都可以 不考虑。这是不完全实现，但是如果是完全实现，即要求所有的属性都是相同的，那么如何实现equals方法？

class Human{

private String name;

private int ago;

private String sex;

....................

public boolean equals(Object obj){

quick check.......

Human other = (Human)ojb;

return this.name.equals(other.name) && this.ago == ohter.ago && this.sex.equals(other.sex);

}

}

这是一个完全实现，但是，有时equals实现是在父类中实现，而要求被子类继承后equals能正确的工

作，这时你并不事实知道子类到底扩展了哪些属性，所以用上面的方法无法使equals得到完全实现。

一个好的方法是利用反射来对equals进行完全实现：

public boolean equals(Object obj){

quick check.......

Class c = this.getClass();

Filed[] fds = c.getDeclaredFields();

for(Filed f:fds){

if(!f.get(this).equals(f.get(obj)))

return false;

}

return true;

}

为了说明的方便，上明的实现省略了异常，这样的实现放在父类中，可以保证你的子类的equals可以按你的愿望正确地工作。关于equals方法的最后一 点是：如果你要是自己重写（正确说应该是履盖）了equals方法，那同时就一定要重写hashCode().这是规范，否则.............

我们还是看一下这个例子：

public final class PhoneNumber {

private final int areaCode;

private final int exchange;

private final int extension;

public PhoneNumber(int areaCode, int exchange, int extension) {

rangeCheck(areaCode, 999, "area code");

rangeCheck(exchange, 99999999, "exchange");

rangeCheck(extension, 9999, "extension");

this.areaCode = areaCode;

this.exchange = exchange;

this.extension = extension;

}

private static void rangeCheck(int arg, int max, String name) {

if(arg < 0 　||　 arg > max)

throw new IllegalArgumentException(name + ": " + arg);

}

public boolean equals(Object o) {

if(o == this)

return true;

if(!(o instanceof PhoneNumber))

return false;

PhoneNumber pn = (PhoneNumber)o;

return pn.extension == extension && pn.exchange == exchange && pn.areaCode == areaCode;

}

}

注意这个类是final的，所以这个equals实现没有什么问题。我们来测试一下:

public static void main(String[] args) {

Map hm = new HashMap();

PhoneNumber pn = new PhoneNumber(123, 38942, 230);

hm.put(pn, "I love you");

PhoneNumber pn1 = new PhoneNumber(123, 38942, 230);

System.out.println(pn);

System.out.println("pn.equals(pn1) is " + pn.equals(pn1));

System.out.println(hm.get(pn1));

System.out.println(hm.get(pn));

}

既然pn.equals(pn1),那么我put(pn,"I love you")后，get(pn1)为什么是null呢？

答案是因为它们的hashCode不一样，而hashMap就是以hashCode为主键的。所以规范要求，如果两个对象进行equals比较时如果返回true,那么它们的hashcode要求返回相等的值。