JVM学习(8)-Java中的四种引用总结

JVM 性能调优 - 四种引用(4) 当垃圾回收时,强引用必定不会被回收,软引用只有在内存紧张时才会被回收,弱引用和虚引用必定被回收。 阅读详情

1.0、四种引用

JDK1.2 之前,Java 中引用的定义很传统:如果 reference 类型的数据存储的数值代表的是另一块内存的起始地址,就称这块内存代表一个引用。

JDK1.2 以后,Java 对引用的概念进行了扩充,将引用分为Strong强引用、Soft软引用、Weak弱引用、Phantom虚引用四种(引用强度逐渐减弱),它们被用来标识对象在GC过程中的生命周期,使得虚拟机更合理地根据内存的大小和对象作用选择是否回收掉这些引用。

以下为本文所要介绍的关键类图:
在这里插入图片描述

2.0、强引用-StrongReference

当内存空间不足时,Java虚拟机宁愿抛出OOM异常也不会对强引用对象进行回收。这是绝大部分的Java对象所处的引用。采用new或者反射创建的对象,都属于强引用,我们可以使用下面的程序进行验证:

public static void main(String[] args) {
        testStrongReference();
    }
    /*
     * @Author ARong
     * @Description 测试强引用在内存不足时是否回收(内存不够用也不回收,直接抛OOM) 	
     * -Xmx1024k -XX:+PrintGCDetails
     * @Param []
     * @return void
     **/
    private static void testStrongReference() {
        Object o1 = new Object();
        Object o2 = o1;
        o1 = null;
        System.out.println("=====GC前=====");
        System.out.println(o1);
        System.out.println(o2);
        // 强制分配1025kb
        try {
            byte[] allocated = new byte[1024 * 1025];
        } catch (Throwable t) {
            t.printStackTrace();
        }finally {
            System.out.println("=====GC后=====");
            System.out.println(o1);
            System.out.println(o2);
        }
    }

运行程序,可以看到属于强引用的对象,在发生GC时也不会被回收掉:

[GC (Allocation Failure) [PSYoungGen: 512K->320K(1024K)] 512K->320K(1536K), 0.0008693 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 825K->496K(1024K)] 825K->512K(1536K), 0.0015158 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 994K->512K(1024K)] 1010K->600K(1536K), 0.0009526 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
=====GC前=====
null
java.lang.Object@5acf9800
[GC (Allocation Failure) [PSYoungGen: 729K->512K(1024K)] 817K->624K(1536K), 0.0020629 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 512K->496K(1024K)] 624K->624K(1536K), 0.0009776 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 496K->481K(1024K)] [ParOldGen: 128K->59K(512K)] 624K->540K(1536K), [Metaspace: 3045K->3045K(1056768K)], 0.0049371 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [PSYoungGen: 481K->496K(1024K)] 540K->563K(1536K), 0.0008344 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 496K->468K(1024K)] [ParOldGen: 67K->56K(512K)] 563K->524K(1536K), [Metaspace: 3045K->3045K(1056768K)], 0.0046858 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
java.lang.OutOfMemoryError: Java heap space
	at jvm_test.ReferenceTest.testStrongReference(ReferenceTest.java:36)
	at jvm_test.ReferenceTest.main(ReferenceTest.java:15)
=====GC后=====
null
java.lang.Object@5acf9800
Heap
 PSYoungGen      total 1024K, used 577K [0x00000007bfe80000, 0x00000007c0000000, 0x00000007c0000000)
  eden space 512K, 21% used [0x00000007bfe80000,0x00000007bfe9b4c0,0x00000007bff00000)
  from space 512K, 91% used [0x00000007bff80000,0x00000007bfff51d0,0x00000007c0000000)
  to   space 512K, 0% used [0x00000007bff00000,0x00000007bff00000,0x00000007bff80000)
 ParOldGen       total 512K, used 56K [0x00000007bfe00000, 0x00000007bfe80000, 0x00000007bfe80000)
  object space 512K, 11% used [0x00000007bfe00000,0x00000007bfe0e190,0x00000007bfe80000)
 Metaspace       used 3127K, capacity 4500K, committed 4864K, reserved 1056768K
  class space    used 342K, capacity 388K, committed 512K, reserved 1048576K

3.0、软引用-SoftReference

当内存空间充足时,不对其回收;当内存空间不足时,对其进行回收。一般用于实现缓存,当内存不足时对缓存的对象进行回收,以免OOM。

/*
     * @Author ARong
     * @Description 测试弱引用在内存不足时是否回收(内存不够则回收,避免OOM) -
     * Xmx1024k -XX:+PrintGCDetails
     * @Param []
     * @return void
     **/
    private static void testSoftReference() {
        Object strongObject = new Object();
        SoftReference<Object> softReference = new SoftReference<Object>(strongObject);
        strongObject = null;
        // GC前
        System.out.println("=====GC前=====");
        System.out.println(strongObject);
        System.out.println(softReference.get());
        // 强制分配1025kb
        try {
            byte[] allocated = new byte[1024 * 1025];
        } catch (Throwable t) {
            t.printStackTrace();
        }finally {
            System.out.println("=====GC后=====");
            System.out.println(strongObject);
            System.out.println(softReference.get());
        }
    }

运行程序,可以发现在内存空间空间充足时,不会对软引用进行回收,而分配1025kb内存后,内存不足,马上对软引用进行了回收。所以软引用适合于作为本地缓存对象来使用,当内存够用,那么可以使用多余的对象作为缓存,当内存不够用,将其进行回收处理。

[GC (Allocation Failure) [PSYoungGen: 512K->368K(1024K)] 512K->368K(1536K), 0.0120415 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [PSYoungGen: 873K->496K(1024K)] 873K->512K(1536K), 0.0011171 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 994K->512K(1024K)] 1010K->600K(1536K), 0.0007085 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
=====GC前=====
null
java.lang.Object@5acf9800
[GC (Allocation Failure) [PSYoungGen: 773K->512K(1024K)] 861K->704K(1536K), 0.0011383 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [PSYoungGen: 512K->512K(1024K)] 704K->704K(1536K), 0.0006836 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 512K->444K(1024K)] [ParOldGen: 192K->123K(512K)] 704K->567K(1536K), [Metaspace: 3071K->3071K(1056768K)], 0.0043012 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 444K->480K(1024K)] 567K->603K(1536K), 0.0008256 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 480K->436K(1024K)] [ParOldGen: 123K->115K(512K)] 603K->551K(1536K), [Metaspace: 3071K->3071K(1056768K)], 0.0052903 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
java.lang.OutOfMemoryError: Java heap space
	at jvm_test.ReferenceTest.testSoftReference(ReferenceTest.java:63)
	at jvm_test.ReferenceTest.main(ReferenceTest.java:16)
=====GC后=====
null
null
Heap
 PSYoungGen      total 1024K, used 543K [0x00000007bfe80000, 0x00000007c0000000, 0x00000007c0000000)
  eden space 512K, 20% used [0x00000007bfe80000,0x00000007bfe9adb0,0x00000007bff00000)
  from space 512K, 85% used [0x00000007bff80000,0x00000007bffed208,0x00000007c0000000)
  to   space 512K, 0% used [0x00000007bff00000,0x00000007bff00000,0x00000007bff80000)
 ParOldGen       total 512K, used 115K [0x00000007bfe00000, 0x00000007bfe80000, 0x00000007bfe80000)
  object space 512K, 22% used [0x00000007bfe00000,0x00000007bfe1cc98,0x00000007bfe80000)
 Metaspace       used 3199K, capacity 4500K, committed 4864K, reserved 1056768K
  class space    used 348K, capacity 388K, committed 512K, reserved 1048576K

4.0、弱引用-WeakReference

垃圾回收器一旦扫描到软引用对象就会立即将其回收。

/*
     * @Author ARong
     * @Description 测试弱引用在内存不足时是否回收(只要扫描到,内存够和不够都回收,避免OOM)
     * @Param []
     * @return void
     **/
    private static void testWeakReference() {
        Object strongObject = new Object();
        WeakReference<Object> weakReference = new WeakReference<Object>(strongObject);
        strongObject = null;
        System.out.println("=====GC扫描前=====");
        System.out.println(strongObject);
        System.out.println(weakReference.get());
        // GC扫描
        System.gc();
        System.out.println("=====GC扫描后=====");
        System.out.println(strongObject);
        System.out.println(weakReference.get());
    }

程序之后后可发现弱引用只要被GC扫描到,内存够和不够都回收。

[GC (Allocation Failure) [PSYoungGen: 512K->384K(1024K)] 512K->384K(1536K), 0.0020183 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [PSYoungGen: 889K->496K(1024K)] 889K->520K(1536K), 0.0027958 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [PSYoungGen: 994K->512K(1024K)] 1018K->608K(1536K), 0.0011595 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
=====GC扫描前=====
null
java.lang.Object@5acf9800
[GC (System.gc()) [PSYoungGen: 765K->496K(1024K)] 861K->656K(1536K), 0.0018561 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (System.gc()) [PSYoungGen: 496K->478K(1024K)] [ParOldGen: 160K->86K(512K)] 656K->564K(1536K), [Metaspace: 3069K->3069K(1056768K)], 0.0051843 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
=====GC扫描后=====
null
null
Heap
 PSYoungGen      total 1024K, used 569K [0x00000007bfe80000, 0x00000007c0000000, 0x00000007c0000000)
  eden space 512K, 17% used [0x00000007bfe80000,0x00000007bfe96d48,0x00000007bff00000)
  from space 512K, 93% used [0x00000007bff80000,0x00000007bfff7888,0x00000007c0000000)
  to   space 512K, 0% used [0x00000007bff00000,0x00000007bff00000,0x00000007bff80000)
 ParOldGen       total 512K, used 86K [0x00000007bfe00000, 0x00000007bfe80000, 0x00000007bfe80000)
  object space 512K, 16% used [0x00000007bfe00000,0x00000007bfe15948,0x00000007bfe80000)
 Metaspace       used 3177K, capacity 4500K, committed 4864K, reserved 1056768K
  class space    used 345K, capacity 388K, committed 512K, reserved 1048576K

5.0、虚引用-PhnatomReference

虚引用并不会决定对象的生命周期,虚引用主要用来跟踪对象被垃圾回收的活动。虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了改虚引用,来了解虚引用标记的对象是否已经被回收,引用队列的作用是用来作为通知。

/*
     * @Author ARong
     * @Description 测试虚引用在内存不足时是否回收  
     * -Xmx1024k -XX:+PrintGCDetails
     * @Param []
     * @return void
     **/
    private static void testPhnatomReference() {
        //虚引用并不起任何作用,而是和引用队列一起使用,当虚引用标记的对象被回收时,引用队列中将出现该虚引用
        Object strongObject = new Object();
        // 引用队列
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        // 创建虚引用,并且与引用队列建立关联
        PhantomReference<Object> phantomReference = new PhantomReference<>(strongObject, referenceQueue);
        System.out.println("=====GC前=====");
        System.out.println(strongObject);
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());

        strongObject = null;
        // 强制分配1025kb, GC
        try {
            byte[] allocated = new byte[1024 * 1025];
        } catch (Throwable t) {
            t.printStackTrace();
        }finally {
            System.out.println("=====GC后=====");
            System.out.println(strongObject);
            System.out.println(phantomReference.get());
            System.out.println(referenceQueue.poll());
        }
    }

执行程序发现,在GC发生前,虚引用中并不存在对象的引用,并且引用队列也是空的。当GC发生后,虚引用标识的对象被回收,引用队列中也出现了相应的引用,这也是虚引用存在的主要意义:作为对象被回收后的通知。

GC (Allocation Failure) [PSYoungGen: 512K->384K(1024K)] 512K->384K(1536K), 0.0009170 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 889K->480K(1024K)] 889K->504K(1536K), 0.0010306 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 978K->480K(1024K)] 1002K->608K(1536K), 0.0009136 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
=====GC前=====
java.lang.Object@5acf9800
null
null
[GC (Allocation Failure) [PSYoungGen: 699K->512K(1024K)] 827K->656K(1536K), 0.0007388 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 512K->496K(1024K)] 656K->656K(1536K), 0.0004858 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 496K->456K(1024K)] [ParOldGen: 160K->84K(512K)] 656K->541K(1536K), [Metaspace: 3050K->3050K(1056768K)], 0.0041626 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 456K->496K(1024K)] 541K->596K(1536K), 0.0005543 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 496K->444K(1024K)] [ParOldGen: 100K->81K(512K)] 596K->525K(1536K), [Metaspace: 3050K->3050K(1056768K)], 0.0046933 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
java.lang.OutOfMemoryError: Java heap space
	at jvm_test.ReferenceTest.testPhnatomReference(ReferenceTest.java:116)
	at jvm_test.ReferenceTest.main(ReferenceTest.java:18)
=====GC后=====
null
null
java.lang.ref.PhantomReference@36baf30c
Heap
 PSYoungGen      total 1024K, used 516K [0x00000007bfe80000, 0x00000007c0000000, 0x00000007c0000000)
  eden space 512K, 14% used [0x00000007bfe80000,0x00000007bfe92178,0x00000007bff00000)
  from space 512K, 86% used [0x00000007bff80000,0x00000007bffef030,0x00000007c0000000)
  to   space 512K, 0% used [0x00000007bff00000,0x00000007bff00000,0x00000007bff80000)
 ParOldGen       total 512K, used 81K [0x00000007bfe00000, 0x00000007bfe80000, 0x00000007bfe80000)
  object space 512K, 15% used [0x00000007bfe00000,0x00000007bfe14560,0x00000007bfe80000)
 Metaspace       used 3105K, capacity 4500K, committed 4864K, reserved 1056768K
  class space    used 342K, capacity 388K, committed 512K, reserved 1048576K

6.0、小结

四种引用类型在GC中回收的情况就介绍完了,再进行以下总结:

  1. 强引用(大部分对象,new出来的对象)
    当内存空间不足时,Java虚拟机宁愿抛出OOM异常也不会对强引用对象进行回收。这是绝大部分的Java对象所处的引用。

  2. 软引用(SoftReference)
    当内存空间充足时,不对其回收;当内存空间不足时,对其进行回收。一般用于实现缓存,当内存不足时对缓存的对象进行回收,以免OOM。

  3. 弱引用 (WeakReference)
    垃圾回收器一旦扫描到软引用对象就会立即将其回收。

  4. 虚引用 (PhantomReference)
    虚引用并不会决定对象的生命周期,虚引用主要用来跟踪对象被垃圾回收的活动。虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了改虚引用,来了解虚引用标记的对象是否已经被回收,引用队列的作用是用来作为通知。

7.0、题外话-WeakHashMap

了解完了四种引用的区别,接下来我们了解一下WeakHashMap。WeakHashMap一般用于缓存数据的存储,当key失效时,value也会被GC清除,以达到节约内存使用的目的。

两者的对比
/**
 * @Auther: ARong
 * @Description: 测试WeakHashMap:用作缓存
 */
public class WeakHashMapTest {
    public static void main(String[] args) {
        hashMapTest();
        System.out.println("==========");
        weakHashMapTest();
    }

    /*
     * @Author ARong
     * @Description 测试HashMap在key为null时发生GC其对应的值是否会回收(不回收)
     * @Param []
     * @return void
     **/
    private static void hashMapTest() {
        HashMap<Integer, String> hashMap = new HashMap<>();
        Integer key = new Integer(1);
        String value = "hashMap";
        hashMap.put(key, value);
        key = null;
        System.gc();
        System.out.println(hashMap);
    }


    /*
     * @Author ARong
     * @Description 测试WeakHashMap在key为null时发生GC其对应的值是否会回收(回收)
     * @Param []
     * @return void
     **/
    private static void weakHashMapTest() {
        WeakHashMap<Integer, String> weakHashMap = new WeakHashMap<>();
        Integer key = new Integer(1);
        String value = "hashMap";
        weakHashMap.put(key, value);
        key = null;
        System.gc();
        System.out.println(weakHashMap);
    }
}

程序执行之后的结果

objc[29697]: Class JavaLaunchHelper is implemented in both /Library/Java/JavaVirtualMachines/jdk1.8.0_40.jdk/Contents/Home/bin/java (0x10f0a54c0) and /Library/Java/JavaVirtualMachines/jdk1.8.0_40.jdk/Contents/Home/jre/lib/libinstrument.dylib (0x10f11b4e0). One of the two will be used. Which one is undefined.
{1=hashMap}
==========
{}

可以看到,在key置为null之后,HashMap中的value还是存在的;而WeakHashMap的key在清空之后,发生GC时已经把相关联的value清除了,减少了内存的占用空间。

jvm四种引用 Java中的引用一共有四种,它们分别是强引用、软引用、弱引用和虚引用,下面我们来分别介绍。 1 首先来说说强引用,强引用就是我们平常用的类似于“Object obj = new Object()”的引用,只要obj的生命周期没结束,或者没有显示地把obj指向为null,那么JVM永远不会回收这种对象。 2 软引用相对强引用来说就要脆弱一点,JVM正常运行时,软引用和强引用没什么区别,但是当内存... 阅读详情

相关推荐

SV fork join_none & for循环结合使用

fork join_none与循环联用常见问题解决方案

ZhangShuHuai11的博客 881

JVM中的五种引用

一 强引用 我们平时使用的大多数对象引用,都是强引用,如下obj就是一个强引用,强引用的特点是:如果所有的GC ROOTS对象都没有与某个对象有强引用路径,那么这个对象就可以被垃圾回收了。 Object obj=new Object(); 二 软引用 通过SoftReference引用对象时,这个引用就是软引用。软引用的特点是:如果一个对象仅存在软引用,当进行GC后,如果内存依旧不够使用,则在下次进行GC时,回收软引用引用的对象。软引用自身也是一个对象(Sof...

男儿当自强 1137

树莓派CM4 PCIe扩展方案与ASM1184e芯片应用

PCIe(Peripheral Component Interconnect Express)是计算机硬件中重要的高速串行总线标准,广泛应用于存储、网络等设备连接。其核心原理是通过差分信号实现高带宽传输,PCIe Gen2 x1的理论带宽可达5Gbps。在嵌入式开发中,PCIe扩展技术能有效解决单板计算机接口不足的问题,特别适合树莓派等微型平台。ASMedia ASM1184e作为PCIe交换芯片,可将单个接口扩展为多个,支持热插拔且免驱动,极大提升了工程灵活性。通过PCIe交换机方案,开发者能在树莓派CM

weixin_42602368的博客 424

Java中的引用类型

Java中的引用类型简介强引用(不回收)软引用(内存不足即回收)弱引用(发现即回收)虚引用(对象回收跟踪) 简介 我们希望能描述这样一类对象:当内存空间还足够时,则能保留在内存中;如果内存空间在进行垃圾手机后还是很紧张,则可以抛弃这些对象。 在JDK 1.2版本之后,Java对引用的概念进行了扩充,将引用分为强引用(Strong Reference)、软引用(Soft Reference)、弱引用(Weak Reference)和虚引用(Phantom Reference)四种,强度一次逐渐减弱。 除强引用

World哥 447

新手必看!无人机定高PID调参避坑指南:从理论到实战的完整流程

本文为无人机新手提供定高PID调参的完整指南,从传感器融合到抗风策略,详细解析多传感器融合、PID控制参数调试及环境干扰应对。通过实战案例和代码示例,帮助开发者快速掌握无人机定高技术,避免常见调参陷阱,提升飞行稳定性。

spark7igniter的博客 222

AI Agent在营销领域的实战策略

本文从第一性原理出发,系统性拆解AI Agent在营销领域的落地逻辑、技术架构、实现方案与实战策略。全文覆盖从基础概念到高级优化的全层级知识:底层理论层面推导营销Agent的效用函数与决策框架;技术架构层面提出"感知-记忆-规划-行动-反思"五组件可落地架构;实践层面提供生产级代码实现、多行业案例与ROI提升方法论;前沿层面探讨多Agent协同、世界模型仿真等下一代技术方向。

操作系统内核探秘的博客 228

JVM的五种引用方式

1、强引用 只有GC root对象都不通过[强引用]引用该对象时,该对象才可以被垃圾回收。 2、软引用 仅有软引用引用该对象时(没有强引用引用该对象),在垃圾回收后,内存依然不足的情况下,会再次触发垃圾回收,此时会回收软引用引用的对象。 可以配合引用队列来释放引用本身 public class TestPerson { public static final int _4MB = 4 * 1024*1024; public static void main(String[] args

F13253524870的博客 551

2023推免(夏令营+套实验室)面试总结(博文附问题汇总和参考答案)

2023推免(夏令营+套实验室)面试总结(博文附问题汇总和参考答案)

m0_51339444的博客 1808

Java的四种引用,强弱软虚,用到的场景。

(1)强引用(StrongReference)强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。如下:Object o=new Object(); // 强引用当内存空间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题。如果不使用时,要通过如下方式来弱化引用,如下:o=null; ...

change的博客 860

LLC变压器,常见的4大问题解决方案

其中之一是当付边的绕组的匝数或层数较多的时候,层间或匝间寄生电容和付边的漏感发生一个寄生的振荡,轻载的时候,这个振铃的幅度会达到很高,导致输出电压比设计的要高许多。但当输入是低压的时候,开关频率比较低,LLC谐振回路的增益较大,因而比较容易发生变压器饱和的问题。由于LLC变压器工作在LC谐振状态,LC谐振回路有个特点就是Q值问题,在这里Q值是大于1的,因而就会有实际加在变压器上的电压要比输入电压高的问题,因而在设计变压器的时候就必须考虑到这一点,否则变压器就不是工作在你设计的磁感应强度上。

1267

整车的智能配电系统

本文探讨了汽车电网安全的重要性,分析了传统汽车电网的现状,并重点介绍了半导体在汽车智能配电系统中的作用。半导体凭借其单向导电性和可控性,如二极管、MOSFET等,提供了更高效、安全的电力控制。通过对比传统保险丝与半导体器件,阐述了半导体在过流保护、电压监测和故障诊断方面的优势,强调其在减少安全隐患、提高能源管理和续航里程方面的贡献。极氪智能配电系统展示了如何运用半导体技术实现整车能源的精细化管理,降低维修成本,减少线束复杂性,提升安全性能。

让你爱上电路设计 1612

【JVM】4种引用和使用场景

JVM中4种引用和使用场景

lp15929801907的博客 1038

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

详解 Java 中的四种引用

前言 在 Java 中,引用随处可见,我们通过类似 Object obj = new Object(); 的代码就可以创建一个引用,而我们直接通过这个代码段创建的引用被称为强引用(StrongReference),这种引用的特点是其指向的对象无论如何都不会被 JVM 的垃圾回收器(Garbage Collector)回收(即使是面临着发生 OutOfMemoryError 异常的风险)。 但是可能...

指点 1万+

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

JAVA中的引用四种引用类型

关于值类型和引用类型的话题,C++、JAVA、python、go、C#等等高级语言都有相关的概念,只要理解了其底层工作原理,可以说即使是不同的语言,在面试学习工作实践中都可以信手拈来(不要太纠集语言),当然此处我选择了JAVA,虽然我是搞C++的,具体原因都懂就不废话了。 一、值类型与引用类型   1、变量初始化 int num=10; String str="hello"      2、变量赋值   从上图可以显而易见,num是int基本类型变量,值就直接保存在变量中。str是String引.

渣渣 8840

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

JAVA四种引用方式

java内存管理分为内存分配和内存回收,都不需要程序员负责,垃圾回收的机制主要是看对象是否有引用指向该对象。 java对象的引用包括   强引用,软引用,弱引用,虚引用 Java中提供这四种引用类型主要有两个目的: 第一是可以让程序员通过代码的方式决定某些对象的生命周期; 第二是有利于JVM进行垃圾回收。 下面来阐述一下这四种类型引用的概念: 1.强引用  是指创建一个对象

我是一个包子 1万+

Java中的四种引用类型

java中的四种引用类型

sugarxxc的博客 8266

【JVM】Java的四种引用详解

在JDK 1.2版之后,Java对引用的概念进行了扩充,将引用分为强引用(Strongly Re-ference)、软引用(Soft Reference)、弱引用(Weak Reference)和虚引用(Phantom Reference)4种,这4种引用强度依次逐渐减弱。...

7me 1万+

JVM中的四种引用类型

java中的内存分配和对象的回收不是程序员控制的,而是java自己管理,通过(Garbage Collector Thread),也就是垃圾收集器线程,根据jvm实现的策略来释放对象内存。 强引用(Strong Reference) Java中默认声明的就是强引用,比如: Object obj = new Object(); //只要obj还指向Object对象,Object对象就不会被回收 ob...

mulinsen77的博客 2390

【JAVA】java中的四种引用

java中的四种引用 JDK1.2之后,把对象的引用分为四种状态,即强引用、软引用、弱引用和虚引用。这样的方式,可以更加灵活地控制对象的生命周期。 一、强引用 开发中用的最多的就是强引用了。 强引用声明格式: String str="abc"; 只要某个对象与强引用关联,那么JVM在内存不足的...

阳阳的博客 3万+

Java中的四种引用详解

Java中有四种引用类型:强引用、软引用、弱引用、虚引用。

2401_87878486的博客 592

【JVM】JAVA中的四种引用

JAVA中的四种引用 强软弱虚 强引用:只要有一个应用指向这个对象,那么垃圾回收器绝不会回收它,当内存不足时报OOM Object obj = new Object(); 软引用:只有内存空间不足时才会去回收它,适用于缓存,不会OOM // jvm -Xmx20m SoftReference<byte[]> ref = new SoftReference<>(new byte[1024 * 1024 * 10]); System.out.println(ref.get());

weixin_42598683的博客 147

JVM四种引用

JVM四种引用概述详解一、强引用(Strong Reference)二、软引用(Soft Reference)三、弱引用(Weak Reference)四、虚引用(Phantom Reference) 引言 在 JDK1.2 版之后,Java 对引用的概念进行了扩充,将引用分为: 强引用(Strong Reference)、软引用(Soft Reference)、弱引用(Weak Reference)、虚引用(Phantom Reference)这 4 种引用强度依次逐渐减弱。 除强引用外,其他 3

qq_35387404的博客 944

JVM中的四种引用:强引用、软引用、弱引用、虚引用。

JVM中的四种引用:强引用、软引用、弱引用、虚引用。 1、强引用 如果一个对象具有强引用,那么垃圾回收器就绝不会回收它。 当内存不足时,JVM宁愿抛出内存溢出异常来终止程序,也不会随意的回收具有强引用的对象来解决内存不足的问题。 例如:A a = new A();就是一个强引用。 2、软引用 如果一个对象只具有软引用,则内存空间足够时,垃圾回收器不会回收它, 如果内存空间

Wpan的博客 1568
上一篇: SpringBoot-优化项目中的异常处理
下一篇: 设计模式(9)-题外话:UML图介绍
BoringRong
BoringRong 领域专家: 后端开发技术领域 领域专家: 后端开发技术领域
博客等级 码龄9年 2万+粉丝 386原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BoringRong

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值