Java 垃圾回收和对象引用

最新推荐文章于 2024-06-10 21:57:08 发布

M_Andrain

最新推荐文章于 2024-06-10 21:57:08 发布

阅读量24

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/M_Andrain/article/details/134738768

版权

一、垃圾回收

Java中垃圾回收算法是可达性分析，要真正回收一个对象，会经历两次标记过程，如果对象在通过可达性算法分析后，没有发现和GC Root相连的引用链，那么就会进行第一次标记（修改Mark Word），标记完之后会进行筛选，判定是否需要执行finalize()方法，如果不需要则直接回收，如果需要，会加入F-Queue队列中，等待执行完finalize之后回收。

下面是一个例子

public class FinalizeGc {

    static  FinalizeGc fg = null;
    public static  void main(String[] args){
        fg = new FinalizeGc();
        fg = null;
        System.gc();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.print("end call by "+Thread.currentThread());
    }
    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("finalize is called by "+Thread.currentThread());
    }
}

输出结果

finalize is called by Thread[Finalizer,8,system]
end call by Thread[main,5,main]

注意：

①如果对象在finalize方法中被其他外部变量重新引用，对象将不会被回收，自行设计实验即可。

② finalize被调用在Finalizer线程，该线程由虚拟机创建，属于deamon线程，而且优先级很低，因此未必等待该方法执行完就会回收垃圾，有可能提取回收。

二、对象引用

1、关于四种引用关系

我们知道对象引用主要分为4种，强引用、软引用、弱引用、虚引用。强引用是编程时主要的引用方式，软引用和弱引用主要解决内存不足的问题，此外弱引用还有解决对方引用不能正确释放的问题。虚引用相当特殊，主要用来监控对象的回收。

1.强引用：

当这个对象被强引用时，就算出现空间内存不足，也要出现oom的情况

2.软引用：

当这个对象被软引用时，一般垃圾回收器不会管它，但是出现空间内存不足，就要被回收。

3.弱引用：

当这个对象被弱引用时，一般还没有出现空间内存不足的情况时，如果垃圾回收器线程扫描到它，就会被回收。

4.虚引用：

当这个对象仅仅被虚引用时，该对象可以在任何时候被垃圾回收。

虚引用主要是用来跟踪对象被垃圾回收的活动。

虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。

当一个对象被回收时，如果发现还有一个虚引用，在回收该对象前，就要把这个虚引用加入到与之相关的引用队列中。

程序通过了解该引用队列，可以判断该对象是否被回收。相当于日志追踪。

2、关于弱引用和虚引用

测试时我们发现，弱引用和虚引用有很多相似之处，也是同样在内存不足是释放对象

测试代码如下：

        Object obj = new long[1024];
        Reference<Object> wf = new PhantomReference<>(obj,new ReferenceQueue<Object>());
        List<Object> eatMemorylist = new ArrayList<>();
        obj  = null;
        while (!wf.isEnqueued()) {
            eatMemorylist.add(new byte[5*1024*1024]);
            //有时候会返回null
            System.out.println(" =>> Object: " + wf.get() + " isEnqueued:" + wf.isEnqueued());
            // wf.isEnQueued();//返回是否被垃圾回收器标记为即将回收的垃圾
            Thread.sleep(1000);

        }

那么问题来了，弱引用和虚引用是否可互相代替呢？

答案：虚引用的get方法实现不允许你获取引用对象


public class PhantomReference<T> extends Reference<T> {

    /**
     * Returns this reference object's referent.  Because the referent of a
     * phantom reference is always inaccessible, this method always returns
     * <code>null</code>.
     *
     * @return  <code>null</code>
     */
    public T get() {
        return null;  //无法使用被引用的对象
    }

    /**
     * Creates a new phantom reference that refers to the given object and
     * is registered with the given queue.
     *
     * <p> It is possible to create a phantom reference with a <tt>null</tt>
     * queue, but such a reference is completely useless: Its <tt>get</tt>
     * method will always return null and, since it does not have a queue, it
     * will never be enqueued.
     *
     * @param referent the object the new phantom reference will refer to
     * @param q the queue with which the reference is to be registered,
     *          or <tt>null</tt> if registration is not required
     */
    public PhantomReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }

}

三、引用Size
Shallow Size
对象自身占用的内存大小，不包括它引用的对象。
针对非数组类型的对象，它的大小就是对象与它所有的成员变量大小的总和。当然这里面还会包括一些java语言特性的数据存储单元。
针对数组类型的对象，它的大小是数组元素对象的大小总和。

Retained Size
Retained Size=当前对象大小+当前对象可直接或间接引用到的对象的大小总和。(间接引用的含义：A->B->C, C就是间接引用)
换句话说，Retained Size就是当前对象被GC后，从Heap上总共能释放掉的内存。
不过，释放的时候还要排除被GC Roots直接或间接引用的对象。他们暂时不会被被当做Garbage。

看图理解Retained Size

上图中，GC Roots直接引用了A和B两个对象。

A对象的Retained Size=A对象的Shallow Size
B对象的Retained Size=B对象的Shallow Size + C对象的Shallow Size

这里不包括D对象，因为D对象被GC Roots直接引用。
如果GC Roots不引用D对象呢？