JVM内存模型

最新推荐文章于 2024-04-22 09:43:27 发布

faith_kevin

最新推荐文章于 2024-04-22 09:43:27 发布

阅读量143

点赞数

本文链接：https://blog.csdn.net/fath_kevin/article/details/81835937

版权

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

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

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

新生代
老年代
永久代

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

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

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

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

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

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

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

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

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

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

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

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

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

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

引用计数法:给对象添加一个引用计数器,当对象增加一次引用时,计数器加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;

}

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

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

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

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

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

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

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

Object obj=new Object();

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

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

Object obj=new Object();

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

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

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

使用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);

}

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

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;