引用计数算法

落日映苍穹つ 2022-08-30 14:52 126阅读 0赞

# 一 点睛 #

在堆里存放着几乎所有的 Java 对象实例，在 GC 执行垃圾回收之前，首先需要区分出内存中哪些是存活对象，哪些是已经死亡的对象。只有被标记为己经死亡的对象，GC 才会在执行垃圾回收时，释放掉其所占用的内存空间，因此这个过程我们可以称为垃圾标记阶段。

那么在 JVM 中究竟是如何标记一个死亡对象呢？简单来说，当一个对象已经不再被任何的存活对象继续引用时，就可以宣判为已经死亡。

## 1 判断对象存活一般有两种算法 ##

*  引用计数算法
 *  可达性分析算法

引用计数算法（Reference Counting）比较简单，对每个对象保存一个整型的引用计数器属性。用于记录对象被引用的情况。

对于一个对象 A，只要有任何一个对象引用了 A，则 A 的引用计数器就加1；当引用失效时，引用计数器就减1。只要对象 A 的引用计数器的值为0，即表示对象 A 不可能再被使用，可进行回收。

## 2 优点 ##

*  实现简单，垃圾对象便于辨识
 *  判定效率高，回收没有延迟性

## 3 缺点 ##

*  它需要单独的字段存储计数器，这样的做法增加了存储空间的开销。
 *  每次赋值都需要更新计数器，伴随着加法和减法操作，这增加了时间开销。
 *  引用计数器有一个严重的问题，即无法处理循环引用的情况。这是一条致命缺陷，导致在 Java 的垃圾回收器中没有使用这类算法。

# 二 循环引用 #

当 p 的指针断开的时候，内部的引用形成一个循环，这就是循环引用，从而造成内存泄漏

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70][]

# 三 实战 #

## 1 需求 ##

使用一个案例来测试 Java 中是否采用的是引用计数算法。

## 2 代码 ##

/**
    * -XX:+PrintGCDetails
    * 证明：java 使用的不是引用计数算法
    */
    public class RefCountGC {
        // 这个成员属性唯一的作用就是占用一点内存
        private byte[] bigSize = new byte[5 * 1024 * 1024]; // 5MB
    
        Object reference = null;
    
        public static void main(String[] args) {
            RefCountGC obj1 = new RefCountGC();
            RefCountGC obj2 = new RefCountGC();
    
            obj1.reference = obj2;
            obj2.reference = obj1;
    
            obj1 = null;
            obj2 = null;
            // 显式的执行垃圾回收行为
            // 这里发生GC，obj1 和 obj2 能否被回收？
            System.gc();
    }

## 3 运行结果 ##

> \[GC (System.gc()) \[PSYoungGen: 13930K->840K(71680K)\] 13930K->848K(235520K), 0.0012726 secs\] \[Times: user=0.00 sys=0.00, real=0.00 secs\]
> 
> \[Full GC (System.gc()) \[PSYoungGen: 840K->0K(71680K)\] \[ParOldGen: 8K->624K(163840K)\] 848K->624K(235520K), \[Metaspace: 3216K->3216K(1056768K)\], 0.0046024 secs\] \[Times: user=0.06 sys=0.00, real=0.01 secs\]
> 
> Heap
> 
> PSYoungGen      total 71680K, used 614K \[0x0000000770580000, 0x0000000775580000, 0x00000007c0000000)
> 
>   eden space 61440K, 1% used \[0x0000000770580000,0x0000000770619b10,0x0000000774180000)
> 
>   from space 10240K, 0% used \[0x0000000774180000,0x0000000774180000,0x0000000774b80000)
> 
>   to   space 10240K, 0% used \[0x0000000774b80000,0x0000000774b80000,0x0000000775580000)
> 
> ParOldGen       total 163840K, used 624K \[0x00000006d1000000, 0x00000006db000000, 0x0000000770580000)
> 
>   object space 163840K, 0% used \[0x00000006d1000000,0x00000006d109c088,0x00000006db000000)
> 
> Metaspace       used 3223K, capacity 4496K, committed 4864K, reserved 1056768K
> 
>   class space    used 348K, capacity 388K, committed 512K, reserved 1048576K

## 4 测试说明 ##

能够看到，上述进行了 GC 收集的行为，将上述的新生代中的两个对象都进行回收了。

如果使用引用计数算法，那么这两个对象将会无法回收。而现在两个对象被回收了，说明 Java 使用的不是引用计数算法来进行标记的。

## 5 图解 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 1][]

# 四 小结 #

引用计数算法，是很多语言的资源回收选择，例如因人工智能而更加火热的 Python，它更是同时支持引用计数和垃圾收集机制。

具体哪种最优是要看场景的，业界有大规模实践中仅保留引用计数机制，以提高吞吐量的尝试。

Java 并没有选择引用计数，是因为其存在一个基本的难题，也就是很难处理循环引用关系。

Python 解决循环引用方法

> 手动解除：很好理解，就是在合适的时机，解除引用关系。
> 
> 使用弱引用 weakref，weakref 是 Python 提供的标准库，旨在解决循环引用。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70]: /images/20220829/74e22482799c4fea9adf320bca799e8d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70 1]: /images/20220829/8b3daff0bec544848816c508071ba8b6.png