JVM内存模型

一,Java虚拟机的内存空间可以分为5个部分:

1. 程序计数器(PC寄存器):用来记录正在执行的虚拟机字节码指令的地址;程序计数器是每个线程私有的,如果线程执行的是非native方法,则程序计数器保存的是当前正在执行指令的地址,若执行的是native方法,则程序计数器保存的是undefined值,也就是空;程序计数器中所存储的数据的大小不会随程序的执行而变化,所以程序计数器不会发生内存溢出的现象;
2. Java栈(虚拟机栈):是Java方法执行的内存模型;每个java方法在执行的时候都会创建一个栈帧,用于存储局部变量表,操作数栈,动态链接,方法出口信息等,每一个放在从调用直至执行过程中,就对应着一个栈帧在jvm中入栈和出栈的过程;同样为线程私有;
   1. 当线程请求的栈深度超过最大值时,会抛出StackOverFlowError异常;
   2. 栈进行动态扩展时如果无法申请到足够内存,会抛出OutOfMemoryError异常;
3. 本地方法栈:与java栈非常相似,只不过他是为本地方法服务的;同样为线程私有;
4. 堆:所有对象实例都在这里分配内存,包括数组(数组的引用在栈中分配内存),该堆是为线程共享的;该区域为线程共享;

在jdk1.8之前,堆可以被分为:

1. 新生代
2. 老年代
3. 永久代

当一个对象被创建时,他首先进入新生代中,之后有可能进入老年代中,新生代中存放着大量生命很短的对象,因此新生代在在三个区域中回收的效率最高;

JDK 1.8 同 JDK 1.7 比，最大的差别就是：元数据区取代了永久代。元空间的本质和永久代类似，都是对 JVM 规范中方法区的实现。不过元空间与永久代之间最大的区别在于：元数据空间并不在虚拟机中，而是使用本地内存。

Java堆不需要连续的内存,并且可以动态的增加其内存,增加失败之后会抛出OutOfMemoryError

1. 方法区:用于存放被虚拟机加载的类信息,常量,静态变量,以及编译器编译后的代码等数据,该区域为线程共享;

和java对一样不需要连续的内存,并且可以动态的扩展,动态扩展失败之后会跑出OutOfMemoryError异常

二:垃圾收集:垃圾收集主要是针对堆和方法区进行垃圾回收(线程之间共享);而对于程序计数器,java栈,本地方法栈,这些线程间私有的区域,只存在于线程的生命周期内,线程结束后也会消失,因此不需要对这三个区域进行垃圾回收;

1. 方法区的回收:主要是针对废弃常量和无用的类进行回收;

(jdk1.7之前,HotSpot虚拟机把他当成永久代来进行垃圾回收,jdk1.8之后,取消了永久代,用metaspace(元数据)替代)

(a):废弃常量:只要常量池中的常量不被任何变量或对象引用,就可以被清除

(b):无用的类:*该该类所有的实例都已经被回收,也就是Java堆不存在任何该类的实例;

                            *加载该类的ClassLoader已经被回收;

                            *该类对应的java.lang.Class对象没有在任何地方被引用,也就是无法在任何地方通过反射访问该类对象   

2.堆区域的回收:主要是对对象的回收;

三;判断一个对象是否可回收:

1. 引用计数法:给对象添加一个引用计数器,当对象增加一次引用时,计数器加1,引用失效时,计数器减1,而引用计数为0的对象就可以被回收;

但是当两个对象出现循环引用的情况时,导致无法对他们进行垃圾回收,所以该计数算法不适合存在循环引用的对象的判断算法

例: public class ReferenceCountingGC {

 

    public Object instance = null;

 

    public static void main(String[] args) {

        ReferenceCountingGC objectA = new ReferenceCountingGC();

        ReferenceCountingGC objectB = new ReferenceCountingGC();

        objectA.instance = objectB;

        objectB.instance = objectA;

    }

}

1. 可达性分析算法:通过GC Roots作为起始点进行搜索,所有与GC Roots直接或者间接关联的对象就是有效对象,和GC Roots无关联的对象就是无效对象

GC Roots:虚拟机栈中引用的对象:

1. 本地方法栈中引用的的对象;
2. 方法区中常量引用的对象
3. 方法区中类静态属性引用的对象

GC Roots并不包括堆中引用的对象,这样就不会出现循环引用;

1. 判断一个对象是否可以被回收,与引用也有关:

1. 强引用:被强引用关联的对象不会被垃圾回收器回收:

使用new一个新对象的方式来创建强引用:

Object obj=new Object();

1. 软引用:被软引用关联的对象只有在内存不够的情况下才会被回收:

使用SoftReference类来创建软引用对象

Object obj=new Object();

SoftReference<Object> softRef=new SoftReference<Object>(obj);

Obj=null;//最后需要去除强引用,使对象只被软引用关联

1. 弱引用:被弱引用关联的对象一定会被垃圾回收器回收,也就是说他只能存活到下一次垃圾收集之前(前提只有若引用,没有强引用)

使用WeakReference类来创建一个弱引用:

Object obj=new Object();

WeakReference<Object> weakRef=new WeakReference<Object>(obj);

Obj=null;//保证使用弱引用:

软引用与弱引用的实现:

package com.deng.jvm;

 

import java.lang.ref.SoftReference;

import java.lang.ref.WeakReference;

 

/*

 * 用来测试JVM中强引用,软引用,弱引用的区别

 * */

public class References_test {

     public static void main(String[] args) {

             //创建一个强引用

             String str=new String("abc");

             //软引用

             SoftReference<String> softRef=new SoftReference<String>(str);

             //去掉强引用

             str=null;

             //启动垃圾回收器

             System.gc();

             //查看软引用的状态

             System.out.println(softRef.get());//被软引用关联的对象,只用在内存不够的情况下,才会被回收

            

             //测试弱引用

             String string=new String("123");

             //创建弱引用

             WeakReference<String> weakRef=new WeakReference<String>(string);

             //去掉强引用

             string=null;

             //启动垃圾回收器

             System.gc();

             //查看弱引用的状态

             System.out.println(weakRef.get());

     }

}

4.使用软引用结合引用队列实现软引用缓存:

使用场景:有些时候,我们希望将数据保存放到缓存池中,这样可以快速进行读取,但是,当JVM中内存不够用时,我们又不希望缓存数据会占用到JVM内存,面对这样的业务场景,通过构建软引用实现的缓存,来达到上述的目的:

(a),定义缓存规范:

package com.deng.SoftRefCache;

/*

 * 用来定义缓存规范

 * */

public interface Cache<k, v> {

public v get(k key);

public boolean set(K key,v value);

}

(b): 定义软引用缓存的基本实现:

package com.deng.SoftRefCache;

 

import java.lang.ref.ReferenceQueue;

import java.util.concurrent.ConcurrentHashMap;

 

/*

 * 用来定义软引用缓存的基本实现

 * */

public abstract class SoftRefCache<K, V> implements Cache<K, V> {

 

//缓存,用软引用记录

private ConcurrentHashMap<K, ExtraInfoReference<v>> cache=new ConcurrentHashMap<K, ExtraInfoReference<v>>();

private ReferenceQueue<v> refQueue=new  ReferenceQueue<v>();

@Override

public V get(K key) {

          V value =null;

         

          if(cache.containsKey(key)) {

                   ExtraInfoReference<V> refValue = cache.get(key);

                   value = refValue.get();

          }

         

          //如果引用被回收

          if(value == null) {

                   //清除软引用队列

                   clearRefQueue();

                   //创建值并放入缓存

                   ExtraInfoReference<v> refValue =new ExtraInfoReference<V>(key, value,refQueue);

                   cache.put(key, refValue);

                  

          }

          return value;

}

 

/*

 * 实现set方法

 * */

@Override

public boolean set(K key, V value) {

          ExtraInfoReference<v> refValue =new ExtraInfoReference<V>(key, value, refQueue);

          cache.put(key, refValue);

          return true;

}

 

/*

 * 定义创建值方法

 * */

protected abstract V createValue(k key);

 

          /*

           * 从软引用中移除无效引用,

           * 同时从cache中删除无效缓存

           * */

@SuppressWarnings("unchecked")

protected void clearRefQueue() {

          ExtraInfoReference<V> refValue =null;

          while((refValue = (ExtraInfoReference<V>) refQueue.poll()) !=null) {

                   K key =(K)refValue.getExtraInfo();

                   cache.remove(key);

          }

}

 

 

}

1. 定义软引用的子类,用来存储额外的信息:

package com.deng.SoftRefCache;

 

import java.lang.ref.ReferenceQueue;

import java.lang.ref.SoftReference;

/*

 * 继承自软引用,用来存储额外的信息

 * */

public class ExtraInfoReference<T> extends SoftReference<T> {

 

   private Object info;

  

   public ExtraInfoReference(Object info,T t, ReferenceQueue<T> refQueue) {

            super(t, refQueue);

            this.info=info;

   }

  

   public Object getExtraInfo() {

            return this.info;

   }

 

}

在以上代码中，定义了一个接口用来规范缓存的实现；同时定义一个软引用缓存类实现缓存接口。在软引用缓存类中，使用ConcurrentHashMap来存放缓存数据。其中值是自定义的软引用类ExtraInfoReference，可存储额外的信息。此处用来存放缓存中的key，可辅助clearRefQueue（)方法进行无效缓存的回收。同时定义createValue(K key)方法需要自定义实现，用来创建缓存数据。

(d)扩展上述软引用基本实现类:

package com.deng.SoftRefCache;

 

public class TestSoftRefCache extends SoftRefCache<String, byte[]> {

      

       /*

        * 创建10M大小的缓存数据

        * */

       @Override

       public  byte[]  createValue(String  key) {

         byte[] bytes=new byte[1024*1021*10];

         return bytes;

       }

 

}

(e)测试:

package com.deng.SoftRefCache;

 

public class SoftRefCacheTest {

       public static void main(String[] args) {

         //创建软引用缓存

         TestSoftRefCache cache=new TestSoftRefCache();

         //for循环10次,相当于向内存中放入了100M数据

         for(int i=0;i<10;i++) {

                  cache.get(String.valueOf(i));

         }

       }

}