【JVM学习02】JVM的垃圾回收

最新推荐文章于 2024-05-05 13:00:41 发布
最新推荐文章于 2024-05-05 13:00:41 发布
阅读量252 收藏 1
点赞数 1
分类专栏： JVM 文章标签： jvm 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54699828/article/details/125862866
版权

文章目录

1. 如何判断对象可以回收

1.1 引用计数法

循环引用

image-20210911105425373

引用计数法即某对象被引用一次，则引用次数加1，当引用次数为0时，则被回收。

但是出现上图循环引用则无法被回收。

1.2可达性分析算法

  • java虚拟机中的垃圾回收器采用可达性分析来探索所有存活的对象。
  • 扫描堆中的对象，看是否能够沿着GC Root对象为起点的引用链找到该对象，找不到，表示可以回收
  • 需要确定根对象，即肯定不会被回收的对象。
  • 垃圾回收前，会对堆中所有的对象进行扫描，只有没有被根对象直接或者间接引用的对象才会被回收。
  • 举个例子，当提起一串葡萄，连在根上的没有掉下来的葡萄即被根对象引用的对象，不能被回收；掉在盘子里的葡萄即可以被回收的对象。

1.3 能够做为GC Root对象的类

  • System Class：系统类
  • Java Native Interface Global：一些本地方法，即native方法
  • Thread：活动中的线程类
  • Busy Monitor：一些锁对象，即加了锁（如被Synchronized修饰）的对象

示例

/**
 * 演示GC Roots
 */
public class Demo2_2 {

    public static void main(String[] args) throws InterruptedException, IOException {
        List<Object> list1 = new ArrayList<>();
        list1.add("a");
        list1.add("b");
        System.out.println(1);
        System.in.read();

        list1 = null;
        System.out.println(2);
        System.in.read();
        System.out.println("end...");
    }
}

运行程序，分别生成垃圾回收前后的dump文件

jps // 查看进程号
// format=b 生成文件格式为二进制；live主动触发垃圾回收，保留存活对象；file表示存放位置
jmap -dump:format=b,live,file=1.bin 进程号51125

list1置空前，生成dump文件1.bin

image-20210911114300327 
List<Object> list1 = new ArrayList<Object>();

list1是局部变量，存在于活动栈帧；new ArrayList<>()产生的对象才是存在于堆中的对象。即此处new ArrayList<>()对应的那个对象才能作为根对象。

list1置空后，生成dump文件2.bin

image-20210911114535971

因为在执行

jmap -dump:format=b,live,file=2.bin 51125

使用了live参数，主动调用了垃圾回收。由于list1被置空，list对象无人引用，所以被垃圾回收了。所以在根对象中找不到了。

2. 四种引用

  1. 强引用
  2. 软引用
  3. 弱引用
  4. 虚引用
  5. 终结器应用

2.1 特点

  1. 强引用
    • 只有所有GC Roots对象都不通过【强引用】引用该对象，该对象才能被垃圾回收。
  2. 软引用（SoftReference）
    • 仅有软引用引用该对象时，在垃圾回收后，内存仍不足时会再次触发垃圾回收，回收软引用对象
    • 可以配合引用队列来释放软引用自身
  3. 弱引用（WeakReference）
    • 仅有弱引用引用该对象时，在垃圾回收时，无论内存是否充足，都会回收弱引用对象。
    • 可以配合引用队列来释放弱引用自身。
  4. 虚引用（PhantomReference）
    • 必须配合引用队列使用，主要配合ByteBuffer使用，被引用对象回收时，会将虚引用入队，由Reference Handler线程调用虚引用相关方法释放直接内存。
  5. 终结器引用（FinalReference）
    • 无需手动编码，但其内部配合引用队列使用，在垃圾回收时，终结器引用入队（被引用对象暂时没有被回收），再由Finalizer线程通过终结器引用找到被引用对象并调用它的finalize()方法，第二次GC时才能回收被引用对象。

2.2 图例

image-20210911154819757
强引用对象回收
image-20210911155008018
软引用对象回收
image-20210911155152121 image-20210911155706625

此时A2对象可能被回收。

  • A2对象仅仅只被软引用对象引用- 在执行GC时，内存空间不足了，才会被垃圾回收
  • 回收后，软引用对象本身可以通过进入引用队列进行释放
弱引用对象的回收
image-20210911155448697

此时A3对象可能会被回收

  • A3对象仅仅被弱引用对象引用
  • 当执行GC时，无论内存是否不足，都会被垃圾回收
  • 回收后，弱引用对象本身可以通过进入引用队列进行释放
虚引用对象的回收
image-20210911155912137 image-20210911155959727

虚引用一般是对直接内存分配的应用。

  • 当声明ByteBuffer时，ByteBuffer会分配一块直接内存，并把直接内存的地址传递给虚引用对象Cleaner。
  • 当ByteBuffer不再被强引用时，被回收后，直接内存还没有被释放。这时会将虚引用放入虚引用的引用队列，由Reference Handler线程监控，发现虚引用对象，调用虚引用相关方法Unsafe.freeMemory释放直接内存。
终结器引用的回收
image-20210911161140742
  • 所有的类都继承自Object类，里面有一个终结方法finalize()方法，当对象重写了finalize()方法，且没有强引用引用它时，它就可以被当成垃圾进行垃圾回收。
  • 当对象没有被强引用时，会由jvm为该对象创建一个对应的终结器引用。当这个对象被垃圾回收时，会将终结器引用加入引用队列，但是对象不会被垃圾回收
  • 再由一个优先级较低的Finalizer线程去监控引用队列是否有终结器引用，如果有，就通过终结器引用找到A4对象，调用其finalize()方法，等调用之后，等下一次垃圾回收时，就可以被垃圾回收了。
  • 工作效率低，第一次GC不会回收对象，先将终结器引用入队，等到第二次垃圾回收才有可能被回收。

2.3 代码示例

软引用
# 虚拟机参数
-Xmx20m -XX:+PrintGCDetails -verbose:gc

/**
 * 演示软引用
 * -Xmx20m -XX:+PrintGCDetails -verbose:gc
 */
public class Demo2_3 {

    private static final int _4MB = 4 * 1024 * 1024;



    public static void main(String[] args) throws IOException {
        //强引用
        /*List<byte[]> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            list.add(new byte[_4MB]);
        }

        System.in.read();*/
        soft();


    }

    public static void soft() {
        // list --> SoftReference --> byte[]

        List<SoftReference<byte[]>> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            SoftReference<byte[]> ref = new SoftReference<>(new byte[_4MB]);
            System.out.println(ref.get());
            list.add(ref);
            System.out.println(list.size());

        }
        System.out.println("循环结束：" + list.size());
        for (SoftReference<byte[]> ref : list) {
            System.out.println(ref.get());
        }
    }
}
image-20210911161930580 
/**
 * 演示软引用, 配合引用队列
 */
public class Demo2_4 {
    private static final int _4MB = 4 * 1024 * 1024;

    public static void main(String[] args) {
        List<SoftReference<byte[]>> list = new ArrayList<>();

        // 引用队列
        ReferenceQueue<byte[]> queue = new ReferenceQueue<>();

        for (int i = 0; i < 5; i++) {
            // 关联了引用队列， 当软引用所关联的 byte[]被回收时，软引用自己会加入到 queue 中去
            SoftReference<byte[]> ref = new SoftReference<>(new byte[_4MB], queue);
            System.out.println(ref.get());
            list.add(ref);
            System.out.println(list.size());
        }

        // 从队列中获取无用的 软引用对象，并移除
        Reference<? extends byte[]> poll = queue.poll();
        while( poll != null) {
            list.remove(poll);
            poll = queue.poll();
        }

        System.out.println("===========================");
        for (SoftReference<byte[]> reference : list) {
            System.out.println(reference.get());
        }

    }
}
image-20210911162312048
弱引用
# 虚拟机参数
-Xmx20m -XX:+PrintGCDetails -verbose:gc


/**
 * 演示弱引用
 * -Xmx20m -XX:+PrintGCDetails -verbose:gc
 */
public class Demo2_5 {
    private static final int _4MB = 4 * 1024 * 1024;

    public static void main(String[] args) {
        //  list --> WeakReference --> byte[]
        List<WeakReference<byte[]>> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            WeakReference<byte[]> ref = new WeakReference<>(new byte[_4MB]);
            list.add(ref);
            for (WeakReference<byte[]> w : list) {
                System.out.print(w.get()+" ");
            }
            System.out.println();

        }
        System.out.println("循环结束：" + list.size());
    }
}
image-20210911162751214

3. 垃圾回收算法

3.1标记清除

image-20210911172543719

将没有被引用的对象标记出来，然后清除。这里的清除并不是把内存空间置零操作，而是把这些空间记录下来，待后面分配空间的时候，去寻找是否有空闲的空间，然后进行覆盖分配。

优点：速度较快

缺陷：清除的空间比较零碎，当待分配的新对象过大，即使零碎空间加起来总共是够的，但是由于过于零散，所以无法对其进行分配。

3.2 标记整理

image-20210911173213209

优点：没有内存碎片，连续空间比较充足

缺点：涉及到地址的改变，开销大，效率低

3.3标记复制

image-20210911173423835 image-20210911173456246 image-20210911173545768

优点：不会有内存碎片

缺陷：始终会占用双倍的内存空间

4. 分代垃圾回收

image-20210914152909431
  • jvm将堆分为了新生代和老年代。
  • 对新生代的垃圾回收（minor GC）更加频繁，对老年代的垃圾回收（full GC）频率低一些
  • 新生代主要存放临时的、迭代快的对象，老年代存放仍然经常使用的对象
  • 新生代类似每天打扫，老年代类似大扫除
    image-20210914154200284
  • 对象首先分配在伊甸园区域。
  • 新生代空间不足时，触发minor gc，伊甸园和from存活的对象使用copy复制到to中，存活的对象年龄加1并且交换from 和 to 所指向的空间，即始终让to空间保持空闲。
  • minor gc 会引发stop the world，暂停其他用户的线程（因为minor gc会重新分配内存地址），等垃圾回收结束，用户线程才恢复运行。
  • 当对象寿命超过阈值时，会晋升至老年代，最大寿命是15（4bit，0000-1111，转成十进制最大标识为15）。
  • 当老年代空间不足，会先尝试触发minor gc，如果之后空间仍不足，那么触发full gc，STW（stop the world）的时间更长
  • 如果仍然不足，会抛出OutOfMemory异常。
4.1 相关VM参数

|含义|参数
|------
|堆初始大小|-Xms
|堆最大大小|-Xmx 或 -XX:MaxHeapSize=size
|新生代大小|-Xmn或（-XX:NewSize=size±XX:MaxNewSize=size）
|幸存区比例（动态）|-XX:InitialSurvivorRatio=ratio和-XX:+UseAdaptiveSizePolicy
|幸存区比例|-XX:SurvivorRatio=ratio
|晋升阈值|-XX:MaxTenuringThreshold=threshold
|晋升详情|-XX:+PrintTenuringDistribution
|GC详情|-XX:+PrintGCDetails -verbose:gc
|FullGC前MinorGC|-XX:+ScavengeBeforeFullGC

4.2 实例
# 虚拟机参数
-Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc -XX:-ScavengeBeforeFullGC


/**
 *  演示内存的分配策略
 */
public class Demo2_1 {<!-- -->
    private static final int _512KB = 512 * 1024;
    private static final int _1MB = 1024 * 1024;
    private static final int _6MB = 6 * 1024 * 1024;
    private static final int _7MB = 7 * 1024 * 1024;
    private static final int _8MB = 8 * 1024 * 1024;

    // -Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc -XX:-ScavengeBeforeFullGC
    public static void main(String[] args) throws InterruptedException {
        
    }
}
image-20210914163100944

当分配空间后

public static void main(String[] args) throws InterruptedException {<!-- -->
    ArrayList<byte[]> list = new ArrayList<byte[]>();
    list.add(new byte[_7MB]);
}
image-20210914164808294

再次分配

public static void main(String[] args) throws InterruptedException {<!-- -->
    ArrayList<byte[]> list = new ArrayList<byte[]>();
    list.add(new byte[_7MB]);
    list.add(new byte[_512KB]);
    list.add(new byte[_512KB]);
}
image-20210914165616334
4.3 大对象直接晋升到老年代
public static void main(String[] args) throws InterruptedException {<!-- -->
    ArrayList<byte[]> list = new ArrayList<byte[]>();
    list.add(new byte[_8MB]);
}
image-20210914170604688

当对象过大，新生代放不下后，不会触发GC，会直接放到老年代。当老年代也不足时，会OOM异常。

进程内的OOM不会影响到主线程的运行

public static void main(String[] args) throws InterruptedException {<!-- -->
    new Thread(() -&gt; {<!-- -->
        ArrayList<byte[]> list = new ArrayList<byte[]>();
        list.add(new byte[_8MB]);
        list.add(new byte[_8MB]);
    }).start();

    System.out.println("sleep....");
    Thread.sleep(1000L);
}
image-20210914170902360

5. 垃圾回收器

串行：

  • 底层是一个单线程的垃圾回收器
  • 适合堆内存较小，cpu数量少，适合个人电脑

吞吐量优先：

  • 多线程
  • 适合堆内存较大的场景
  • 需要多核cpu支持（否则多线程争强一个cpu效率低）
  • 让单位时间内，STW的时间最短 0.2 + 0.2 = 0.4

响应时间优先：

  • 多线程
  • 适合堆内存较大
  • 需要多核cpu
  • 尽可能让单次STW的时间最短 0.1 + 0.1 + 0.1 + 0.1 + 0.1 = 0.5

5.1 串行

# 虚拟机参数
-XX:+UseSerialGC=Serial+SerialOld

串行垃圾回收器分为两个部分，分开运行的。新生代空间不足了触发Serial完成MinorGC，老年代空间不足了触发SerialOld完成FullGC
Serial

  • 工作在新生代: 标记复制算法
  • 工作在老年代: 标记整理算法
image-20210914172536866

5.2 吞吐量优先

# 虚拟机参数
# 并行
-XX:+UseParallelGC ~ -XX:+UseParallelOldGC
-XX:+UseAdaptiveSizePolicy
-XX:GCTimeRatio=ratio
-XX:MaxGCPauseMillis=ms
-XX:ParallelGCThreads=n

image-20220717211743381

image-20210914173602885
  • parallel并行，指的是，多个垃圾回收器可以并行的运行，占用不同的cpu。但是在此期间，用户线程是被暂停的，只有垃圾回收线程在运行。

5.3 响应时间优先

# 虚拟机参数
# 并发
-XX:+UseConcMarkSweepGC~ -XX:+UseParNewGC~SerialOld
-XX:ParallelGCThreads=n~ -XX:ConcGCTreads=threads
-XX:CMSInitiatingOccupancyFraction=percent
-XX:+CMSScavengeBeforeRemark
image-20210914192429184

  • Concurrent 并发、MarkSweep标记清除。基于标记清除且支持并发的一个垃圾回收器

  • 并发意味着垃圾回收时，其他的用户线程也可以并发运行，与垃圾回收线程抢占cpu

  • CMS在垃圾回收的某些阶段是不需要STW，进一步减少需要STW的时间

  • UseConcMarkSweepGC是工作在老年代的垃圾回收器，与之对应的是UseParNewGC，工作在新生代的垃圾回收器，基于复制算法。

  • CMS回收器有时候会发生并行失败的情况，这时候CMS回收器会退化成SerialOld的单线程的基于标记整理的垃圾回收器。

    CMS老年代回收过程

image-20210914193509273

  • 当老年代空间不足时，所有进程运行到安全点暂停，然后垃圾回收的线程进行初始标记，初始标记比较快，只是标记根对象。此过程会Stop The World，阻塞其他用户线程。

  • 之后达到下一个安全点，其他用户线程也可以继续运行了，此时垃圾回收线程进行并发标记，即可以跟其他用户线程并发工作，然后讲垃圾标记出来。此过程不会STW

  • 达到下一个安全点后，进行重新标记，因为上一个并发标记时，其他用户线程也在并发执行，所有可能会产生新对象新引用，对垃圾回收线程造成了干扰，需要重新标记。此过程会STW

  • 到下一个安全点后，其他用户进程恢复，垃圾回收线程开始并发地清理垃圾，恢复运行。

    细节
    垃圾回收的并发数受参数影响。

    • -XX:ParallelGCThreads=n 表示并行的垃圾回收线程数，一般跟cpu数目相等
    • -XX:ConcGCTreads=threads 并发的垃圾回收线程数目，一般是ParallelGCThreads的 1/4。即一个cpu做垃圾回收，剩下3个cpu留给人家用户线程。

5.4 G1

定义：Garbage First

  • 2004论文发布- 2009JDK6u14体验- 2012JDK7u4官方支持- 2017JDK9默认
    使用场景
  • 同时注重吞吐量（Throughput）和低延迟（Low latency），默认的暂停目标是200ms- 超大堆内存，会将堆划分为多个大小相等的Region（每个Region可以分新生代老年代）- 整体上是标记+整理算法，两个区域之间是复制算法
    相关JVM参数
-XX:+UseG1GC
-XX:G1HeapRegionSize=size
-XX:MaxGCPauseMillis=time
G1垃圾回收阶段
image-20210915112021863

新生代的回收之后，可以在进行新生代回收时，同时并发标记，然后再进行混合垃圾回收，即对新生代、老年代都进行一次较大的垃圾回收。

Young Collection
  • 会STW（时间较短）
    image-20210915112537122
image-20210915113142967 image-20210915113421900
Young Collection +CM
  • 新生代的垃圾回收+并发标记阶段-
  • 在YoungGC时会进行GC Root的初始标记-
  • 并发标记，顺着GC Roots找到其他对象-
  • 老年代占用堆空间比例达到阈值时，进行并发标记（不会STW），由下面的JVM参数决定
-XX:InitiatingHeapOccupancyPercent=percent(默认45％)
image-20210915114111537
Mixed Collection

混合收集， 会对E、S、O进行全面垃圾回收

  • 最终标记（Remark）会STW
  • 拷贝存活（EVacuation）会STW
-XX:MaxGCPauseMillis=ms
image-20210915152035617 - 因为在此之前有并发标记，所以需要最终标记并拷贝存活 - 新生代的存活对象通过复制算法到幸存区 - 幸存区的一些达到晋升寿命的对象，晋升到老年代 - 对于老年代的垃圾回收来说，并不会全部回收。为了达到暂停时间短（STW），会优先让一部分垃圾回收价值高的老年代回收(即选择能够回收较多垃圾的老年代进行回收操作)。与MaxGCPauseMillis参数有关
Full GC
  • SerialGC
    新生代内存不足发生的垃圾收集 ——minor gc
    老年代内存不足发生的垃圾收集 ——full gc
  • ParallelGC
    新生代内存不足发生的垃圾收集 ——minor gc
    老年代内存不足发生的垃圾收集 ——full gc
  • CMS
    新生代内存不足发生的垃圾回收 ——minor gc
    老年代内存不足
    当垃圾回收速度跟不上垃圾生成速度时，会full gc
    并发收集失败前是minor gc，并发失败退化为串行垃圾收集器，触发full gc
  • G1
    新生代内存不足发生的垃圾回收 ——minor gc
    老年代内存不足（到达设定的阈值）
    当垃圾回收速度跟不上垃圾生成速度时，会full gc
    并发收集失败前是minor gc，并发失败退化为串行垃圾收集器，触发full gc
Young Collction跨代引用
  • 新生代回收的跨代引用（老年代引用新生代）问题

  • 老年代会再细分，会形成一个卡表，老年代里引用新生代的对象会被标记为dirty card。
  • 卡表与Remember Set（标记为dirty card的集合）
  • 在引用变更时通过post-write barrier + dirty card queue
  • concurrent refinement threads 更新 Remember Set
Remark
  • 重标记
  • pre-write barrier（写屏障） + satb_mark_queue（队列名称）

在这里插入图片描述

黑色：已处理完成，不会被垃圾回收

白色：已处理完成，会被垃圾回收

灰色：正在处理

image-20210915155930677

B会被标记为黑色

因为是并发标记，其他用户线程在工作，可能将C的引用改变

image-20210915160019674

C已经被处理过了，本来应该被直接回收，但是显然C被其他用户线程改变引用了。所以需要对对象的引用进行进一步检查。

当对象的引用发生改变时，jvm会对该对象加上写屏障pre-write barrier，会把对象C加入到一个队列satb_mark_queue，并且标记为灰色，表示正在处理。

等到并发标记结束，进行重新标记，会STW，暂停其他线程，然后将线程里的对象取出来检查，发现对象是灰色，还需要进行处理。在处理的时候发现，有强引用引用该对象，那么标记为黑色，即处理结束且不会被回收。

JDK 8u20字符串去重
  • 优点：节省大量空间- 缺点：略微多占用了cpu空间，新生代回收时间略微增加
-XX:+UseStringDeduplication

String s1 = new String("hello"); //char[]{'h','e','l','l','o'}
String s1 = new String("hello"); //char[]{'h','e','l','l','o'}
system.out.println(s1==s2)  //false
  • 将所有新分配的字符串放入一个队列
  • 当新生代回收时，G1并发检查是否有字符串重复
  • 如果它们值一样，让它们引用同一个char[]
  • 注意，与String.intern()不一样
    • String.intern()关注的是字符串对象
    • 而字符串去重关注的是char[]
    • 在JVM内部，使用了不同的字符串表
JDK 8u40并发标记类卸载

所有对象都经过并发标记后，就能知道哪些类不再被使用，当一个类加载器的所有类都不再使用，则卸载它所加载的所有类。

-XX:+ClassUnloadWithConcurrentMark # 默认启用
JDK 8u60回收巨型对象
  • 一个对象大于region的一半时，称之为巨型对象- G1不会对巨型对象进行拷贝- 回收时被优先考虑- G1会跟踪老年代所有incoming引用，这样老年代incoming引用为0的巨型对象就可以在新生代垃圾回收时处理掉。
    image-20210915164307591
JDK 9并发标记起始时间的调整
  • 并发标记必须在堆空间占满前完成，否则退化为FullGC- JDK9之前需要使用 -XX:InitiatingHeapOccupancyPercent
  • JDK9可以动态调整
    • - -XX:InitiatingHeapOccupancyPercent 用来设置初始值- 进行数据采样并动态调整- 总会添加一个安全的空档空间 目的是尽早地开始垃圾回收，避免Full GC的发生。
JDK 9更高效的回收
  • 250+增强- 180+bug修复- https://docs.oracle.com/en/java/javase/12/gctuning

DK 8u40并发标记类卸载

所有对象都经过并发标记后，就能知道哪些类不再被使用，当一个类加载器的所有类都不再使用，则卸载它所加载的所有类。

-XX:+ClassUnloadWithConcurrentMark # 默认启用
JDK 8u60回收巨型对象
  • 一个对象大于region的一半时，称之为巨型对象- G1不会对巨型对象进行拷贝- 回收时被优先考虑- G1会跟踪老年代所有incoming引用，这样老年代incoming引用为0的巨型对象就可以在新生代垃圾回收时处理掉。
    image-20210915164307591
JDK 9并发标记起始时间的调整
  • 并发标记必须在堆空间占满前完成，否则退化为FullGC- JDK9之前需要使用 -XX:InitiatingHeapOccupancyPercent
  • JDK9可以动态调整
    • - -XX:InitiatingHeapOccupancyPercent 用来设置初始值- 进行数据采样并动态调整- 总会添加一个安全的空档空间 目的是尽早地开始垃圾回收，避免Full GC的发生。
JDK 9更高效的回收
  • 250+增强- 180+bug修复- https://docs.oracle.com/en/java/javase/12/gctuning
ぃ小男孩つ
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
简单理解JVM垃圾回收
01-20
文章目录如何判断一个对象是垃圾垃圾回收算法分代收集算法垃圾收集器相关知识总结 如何判断一个对象是垃圾 我们都知道了当堆中的区域没有足够内存去存放对象时就会触发垃圾回收，那么如何来判断一个对象是不是垃圾呢？ 1.引用计数法： 一旦相互持有引用，就导致对象永远没法被回收 例如： 给对象定义一个引用计数器，当该对象被引用时该计数器就++，引用结束时就–。那么当垃圾回收时就会回收掉计数器为0的对象。 那么就有个问题，如果两个本身是无用的对象相互引用，瞒天过海，瞒过JVM就会导致这两个对象永远不会被回收掉。 2.可达性分析 由GC Root出发，开始寻找，看看某个对象是否可达 GC Root：可以是
41. 如何手动触发全量回收垃圾，如何立即触发垃圾回收
weixin_30919571的博客
08-13 1624
垃圾回收机制具有的特征 垃圾回收机制只负责回收堆内存的对象，不会回收任何物理资源（例如数据库连接、网络IO等资源） 程序无法精确控制垃圾回收的运行，垃圾回收会在合适的时候进行。当对象永久地失去引用后，系统就会在合适的时候回收它所占的内存 在垃圾回收机制回收任何对象之前，总会先调用它的finalize()方法，该方法可能使该对象重新复活（让一个引用变量重新引用该对象），从而导致垃圾回收机制...
关于是否用Java代码主动进行垃圾回收
qq_28883811的博客
10-26 2565
虽然做了几年的Java，但是对原理性的东西了解很少，特别是在前几天面试的时候让我有了更深的感触，那个人问我有没有在Java代码里面实现过主动进行回收垃圾的操作，当时我也是一脸懵逼，直到今天查看了些文章才明白是怎么回事。        原来System.gc就是主动去进行垃圾回收。     但是System.gc执行时就会停止整个应用的所有响应，假如这一时刻有很多很多的垃圾需要被回收，同时又有很
js 垃圾回收机制
weixin_62548988的博客
07-28 84
js 具有自动垃圾回收机制。垃圾收集器会按照固定的时间间隔周期性的执行。js 常见的垃圾回收方式：标记清除、引用计数方式。
【深入理解Java原理】垃圾回收原理
王小明的专栏
07-25 5487
内存模型相关 什么时候触发GC？ 本文章完整内容发表在公众号：程序员开发者社区，关注后免费看 内存模型相关参考：点击打开链接 CMS垃圾回收器 Concurent Marked Sweep 并行的标记垃圾回收器 获取最短停顿的回收器， 标记清除算法实现 缺点是： 1.对cpu资源敏感 2.无法处理浮动垃圾 3....
ZGC的7种垃圾回收触发时机
weixin_41018580的博客
07-06 3412
ZGC中，为了实现更高的性能，尽量避免进行同步垃圾回收，也就是说尽量避免触发同步的垃圾回收的消息。ZGC中触发同步消息的场景也比较少，总体以触发异步消息为主。异步消息主要由ZDirector根据规则判断是否可以触发，在ZDirector流程图中【了解更多，可以阅读小编的另一篇文章：ZGC线程之时钟触发器和消息触发】介绍了ZDirector有4种触发规则，本文主要介绍这4种规则是如何触发的，最后，还会简要介绍其他的垃圾回收消息是如何触发的。 一、基于固定时间间隔触发 ZDirector提供的第一个规则就是基于
主动垃圾回收
qq_33114869的博客
05-15 239
JVM主动垃圾回收jvm怎么实现主动垃圾回收呢？ jvm怎么实现主动垃圾回收呢？ 由于垃圾回收器的存在，Java语言本身没有给开发人员提供显式释放已分配内存的方法，也就是说，开发人员不能实时地调用垃圾回收器对某个对象或所有对象进行垃圾回收。但开发人员却可以通过调用System.gc()方法来“通知”垃圾回收器运行，当然，JVM也并不会保证垃圾回收器马上就会运行。由于System.gc()方法的执行会停止所有响应，去检查内存中是否有可回收的对象，这会对程序的正常运行以及性能造成极大的威胁，因此实际编程时，不推
jvm垃圾回收是什么时候触发的？ 垃圾回收算法？ 都有哪些垃圾回收器
热门推荐
sunny的专栏
10-12 3万+
1.1。那究竟GC为我们做了什么操作呢？ 1 ，哪些内存需要回收？    2 ，什么时候回收？    3 ，如何回收？     这时候有人就会疑惑了，既然GC 已经为我们解决了这个矛盾，我们还需要学习GC 么？当然当然是肯定的，那究竟什么时候我们还需要用到的呢？ 1 ，排查内存溢出    2 ，排查内存泄漏    3 ，性能调优，排查并发瓶颈    1.1.1。JVM怎么判断对象可以回收了？我们知...
static变量会被垃圾回收吗_当对象不可达一定会被JVM回收吗？
weixin_39725924的博客
12-14 762
看到标题这如果是判断题那简直就是送分儿题，答案很明显：不一定。如果是问答题，那还得解释一下为啥不一定，不然交卷也不可能是满分或者高分，这在面试的时候一样如此。那因为啥不一定被JVM垃圾回收器回收呢？这是因为JVM的垃圾回收算法设计的宽容性，好不容易生产的对象咋能随便就收了，万一又可达了呢。何时一定被回收？先看一段代码：public class LiveInGC { private static L...
JVM之垃圾回收
qq_35597828的博客
04-08 551
简介 JVM具有自动垃圾回收处理，比起手动回收，开发效率提高了，并且不会出现忘记回收和多次回收的问题。通过了解垃圾回收的原理，选择合适的垃圾回收器，可以提高程序的性能。 如何标记垃圾 在没有任何引用指向一个对象时称为垃圾，通过引用计数法/根可达算法来标记垃圾 引用计数法就是通过给对象添加一个引用计数器，有对象被一个地方引用时，计数器加1，当没引用时则减1，这种算法有一个缺陷，无法标记互相引用的对象，在Java中没用这种算法作为标记垃圾的算法 根可达算法就是通过一些GC Roots的对象作为起始点，
Java+JVM+垃圾回收机制
02-25
该资源通过图像及文字详细分析回答了JVM垃圾回收机制的三个重要面试问题： 1.哪些垃圾是需要回收的？ 判断对象是否需要回收有两种算法。一种是引用计数算法、一种是可达性分析算法。 2.有哪些重要的垃圾回收算法？ ...
浅析JVM垃圾回收的过程
09-07
主要介绍了JVM垃圾回收的过程，帮助大家更好的理解和学习Java中的垃圾回收机制，感兴趣的朋友可以了解下
JVM垃圾回收机制(GC)
12-21
JVM垃圾回收机制(GC) 引入：我们都知道，栈内存中方法运行完毕后会有弹栈的操作，不会产生垃圾，而堆内存中却没有这种操作，当堆内存中很多无用的成员变量、对象等等积压到一定程度时，就会发生堆内存溢出的一个错误...
JVM垃圾回收机制.xmind
03-31
自己学习总结JVM垃圾回收机制的结构图，一起分享！！！
JVM的垃圾回收机制详解和调优
12-31
gc即垃圾收集机制是指jvm用于释放那些不再使用的对象所占用的内存。java语言并不要求jvm有gc，也没有规定gc如何工作。不过常用的jvm都有gc，而且大多数gc都使用类似的算法管理内存和执行收集操作。 在充分理解了...
jvm 马士兵 01 JVM简介，class文件结构
qq_38757863的博客
04-30 274
01.JVM是什么。
JVM笔记4-虚拟机类加载机制
最新发布
qq_41056506的博客
05-05 649
【代码】JVM笔记4-虚拟机类加载机制。
01 JVM -- JVM 体系结构、HotSpot
m0_46671240的博客
05-04 281
01 JVM -- JVM 体系结构、HotSpot
Java八股文3
qq_64064246的博客
05-05 460
有两种方式来确定，第一个是引用计数法，第二个是可达性分析算法。
jvm怎么配置垃圾回收
01-13
JVM的垃圾回收可以通过配置不同的参数来进行调整。以下是一些常用的垃圾回收相关的JVM参数配置： 1. -Xmx：设置JVM堆的最大内存大小。例如，-Xmx2g表示将最大堆内存设置为2GB。 2. -Xms：设置JVM堆的初始内存大小...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值