java List是强引用吗_jvm：java中的引用（强引用、软引用、虚引用、弱引用）

最新推荐文章于 2024-07-15 23:17:41 发布
最新推荐文章于 2024-07-15 23:17:41 发布
阅读量253 收藏
点赞数
文章标签： java List是强引用吗
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_31965935/article/details/114551875
版权

1、分类

强引用、软引用、弱引用、虚引用、终结器引用

0845f3bcc9b1abd889ed3123a19a6b95.png

强引用：只要能够通过GC Root的引用链找到就不会被垃圾回收，也就是说只有所有的GC Roots对象都不通过强引用引用该对象的时候，该对象才能被垃圾回收

弱引用：如果某个对象与弱引用关联，那么当JVM在进行垃圾回收时，无论内存是否充足，都会回收此类对象。

软引用：java中使用SoftRefence来表示软引用，如果某个对象与软引用关联，那么JVM只会在内存不足的情况下回收该对象

虚引用：创建的时候会关联一个引用队列

例如：创建ByteBuffer的时候会创建一个名为Cleaner的虚引用对象，当ByteBuffer没有被强引用所引用就会被jvm垃圾回收，虚引用Cleaner就会进入引用队列，会有专门的线程扫描引用队列，被发现后会调用直接内存地址的方法将直接内存释放掉，保证直接内存不会导致内存泄漏

是所有引用类型中最弱的，一个对象是否有虚引用的存在，完全不会对其生命周期构成影响，也无法通过虚引用获得一个对象实例。

终结器引用：创建的时候会关联一个引用队列，当A4对象没有被强引用所引用时，A4被垃圾回收的时候，会将终结器引用放入到一个引用队列(被引用对象暂时还没有被垃圾回收)，有专门的线程(优先级较低，可能会造成对象迟迟不被回收)扫描引用队列并调用finallize()方法，第二次GC的时候才能回收掉被引用对象

2、强引用

(1)强引用的使用：

设置jvm的内存为20M

e950cb95155eff8389825e6a36fdb40a.png

public classTest2 {public static final int _4MB=4*1024*1024;public static void main(String[] args) throwsIOException {

List list =new ArrayList<>();for(int i=0;i<5;i++){

list.add(new byte[_4MB]);

}

System.in.read();

}

}

运行上面的程序会出现内存溢出问题，也就是说有的内存即使不太重要依旧会被占用：

Exception in thread "main"java.lang.OutOfMemoryError: Java heap space

at pers.zhb.test.Test2.main(Test2.java:12)

3、软引用

(1)软引用的场景：

输入jvm指令：

47c15dc675a2a910e4652f5e6bf1ac40.png

public classTest2 {private static final int _4MB=4*1024*1024;public static void main(String[] args) throwsIOException {

soft();

}public static voidsoft(){

List> list=new ArrayList<>();for(int i=0;i<5;i++){

SoftReference reference=new SoftReference<>(new byte[_4MB]);

System.out.println(reference.get());

list.add(reference);

System.out.println(list.size());

}

System.out.println("循环结束："+list.size());for(SoftReferencereference:list){

System.out.println(reference.get());

}

}

}

运行结果：

[B@1b6d35861[B@4554617c2[B@74a144823[GC (Allocation Failure) [PSYoungGen: 1744K->488K(6144K)] 14032K->12932K(19968K), 0.0427814 secs] [Times: user=0.00 sys=0.00, real=0.05secs]

[B@1540e19d

4[GC (Allocation Failure)--[PSYoungGen: 4696K->4696K(6144K)] 17140K->17140K(19968K), 0.0030222 secs] [Times: user=0.00 sys=0.00, real=0.00secs]

[Full GC (Ergonomics) [PSYoungGen: 4696K->4574K(6144K)] [ParOldGen: 12444K->12414K(13824K)] 17140K->16988K(19968K), [Metaspace: 3118K->3118K(1056768K)], 0.0095409 secs] [Times: user=0.00 sys=0.00, real=0.01secs]

[GC (Allocation Failure)--[PSYoungGen: 4574K->4574K(6144K)] 16988K->16996K(19968K), 0.0010492 secs] [Times: user=0.00 sys=0.00, real=0.00secs]

[Full GC (Allocation Failure) [PSYoungGen: 4574K->0K(6144K)] [ParOldGen: 12422K->587K(8704K)] 16996K->587K(14848K), [Metaspace: 3118K->3118K(1056768K)], 0.0076471 secs] [Times: user=0.03 sys=0.00, real=0.01secs]

[B@677327b65循环结束：5

null

null

null

null[B@677327b6

Heap

PSYoungGen total 6144K, used 4546K [0x00000000ff980000, 0x0000000100000000, 0x0000000100000000)

eden space 5632K,80% used [0x00000000ff980000,0x00000000ffdf0940,0x00000000fff00000)

from space 512K,0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)

to space 512K,0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)

ParOldGen total 8704K, used 587K [0x00000000fec00000, 0x00000000ff480000, 0x00000000ff980000)

object space 8704K,6% used [0x00000000fec00000,0x00000000fec92d20,0x00000000ff480000)

Metaspace used 3224K, capacity 4500K, committed 4864K, reserved 1056768Kclass space used 349K, capacity 388K, committed 512K, reserved 1048576K

可以看出，在第四次和第五次的时候就触发了垃圾回收，在对集合进行遍历后只有第五个软引用对象存在，也就是说在内存不足的时候将前面的虚引用的对象进行了垃圾回收

(2)软引用与引用队列：

public classTest2 {private static final int _4MB=4*1024*1024;public static void main(String[] args) throwsIOException {

List> list=new ArrayList<>();//引用队列

ReferenceQueue queue=new ReferenceQueue<>();for(int i=0;i<5;i++){//关联了引用队列，当软引用所关联的byte数组被回收时，软引用自己会加入到引用队列中

SoftReference reference=new SoftReference<>(new byte[_4MB],queue);

System.out.println(reference.get());

list.add(reference);

System.out.println(list.size());

}//从队列获取无用的软引用对象并移除

Reference extends byte[]> poll=queue.poll();while(poll!=null){

list.remove(poll);

poll=queue.poll();

}

System.out.println("循环结束");for(SoftReferencereference:list){

System.out.println(reference.get());

}

}

}

测试：

[B@1b6d3586

1

[B@4554617c

2

[B@74a14482

3

[GC (Allocation Failure) [PSYoungGen: 1866K->488K(6144K)] 14154K->12964K(19968K), 0.0010895 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

[B@1540e19d

4

[GC (Allocation Failure) --[PSYoungGen: 4696K->4696K(6144K)] 17172K->17180K(19968K), 0.0011250 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

[Full GC (Ergonomics) [PSYoungGen: 4696K->4564K(6144K)] [ParOldGen: 12484K->12458K(13824K)] 17180K->17022K(19968K), [Metaspace: 3228K->3228K(1056768K)], 0.0055610 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]

[GC (Allocation Failure) --[PSYoungGen: 4564K->4564K(6144K)] 17022K->17030K(19968K), 0.0009186 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

[Full GC (Allocation Failure) [PSYoungGen: 4564K->0K(6144K)] [ParOldGen: 12466K->620K(8704K)] 17030K->620K(14848K), [Metaspace: 3228K->3228K(1056768K)], 0.0065061 secs] [Times: user=0.00 sys=0.01, real=0.01 secs]

[B@677327b6

5

循环结束

[B@677327b6

Heap

PSYoungGen total 6144K, used 4546K [0x00000000ff980000, 0x0000000100000000, 0x0000000100000000)

eden space 5632K, 80% used [0x00000000ff980000,0x00000000ffdf0918,0x00000000fff00000)

from space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)

to space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)

ParOldGen total 8704K, used 620K [0x00000000fec00000, 0x00000000ff480000, 0x00000000ff980000)

object space 8704K, 7% used [0x00000000fec00000,0x00000000fec9b160,0x00000000ff480000)

Metaspace used 3237K, capacity 4500K, committed 4864K, reserved 1056768K

class space used 351K, capacity 388K, committed 512K, reserved 1048576K

Process finished with exit code 0

4、弱引用

4ade4832af2cab91b41275acc873beca.png

(1)弱引用举例

public classTest2 {private static final int _4MB = 4 * 1024 * 1024;public static void main(String[] args) throwsIOException {

List> list = new ArrayList<>();for (int i = 0; i < 10; i++) {

WeakReference reference = new WeakReference<>(new byte[_4MB]);

list.add(reference);for (WeakReferencew : list) {

System.out.println(w.get());

}

System.out.println();

}

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

}

}

(2)测试：

[B@1b6d3586

[B@1b6d3586

[B@4554617c

[B@1b6d3586

[B@4554617c

[B@74a14482

[GC (Allocation Failure) [PSYoungGen: 1865K->488K(6144K)] 14153K->12992K(19968K), 0.0014680 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

[B@1b6d3586

[B@4554617c

[B@74a14482

[B@1540e19d

[GC (Allocation Failure) [PSYoungGen: 4809K->496K(6144K)] 17313K->13044K(19968K), 0.0013554 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

[B@1b6d3586

[B@4554617c

[B@74a14482

null

[B@677327b6

[GC (Allocation Failure) [PSYoungGen: 4702K->472K(6144K)] 17250K->13020K(19968K), 0.0017348 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

[B@1b6d3586

[B@4554617c

[B@74a14482

null

null

[B@14ae5a5

[GC (Allocation Failure) [PSYoungGen: 4678K->488K(6144K)] 17226K->13036K(19968K), 0.0016909 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

[B@1b6d3586

[B@4554617c

[B@74a14482

null

null

null

[B@7f31245a

[GC (Allocation Failure) [PSYoungGen: 4694K->488K(6144K)] 17242K->13044K(19968K), 0.0008993 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

[B@1b6d3586

[B@4554617c

[B@74a14482

null

null

null

null

[B@6d6f6e28

[GC (Allocation Failure) [PSYoungGen: 4694K->472K(5120K)] 17250K->13028K(18944K), 0.0011246 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

[B@1b6d3586

[B@4554617c

[B@74a14482

null

null

null

null

null

[B@135fbaa4

[GC (Allocation Failure) [PSYoungGen: 4657K->32K(5632K)] 17214K->13012K(19456K), 0.0012595 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]

[Full GC (Ergonomics) [PSYoungGen: 32K->0K(5632K)] [ParOldGen: 12980K->638K(7680K)] 13012K->638K(13312K), [Metaspace: 3232K->3232K(1056768K)], 0.0084781 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]

null

null

null

null

null

null

null

null

null

[B@45ee12a7

循环结束：10

Heap

PSYoungGen total 5632K, used 4371K [0x00000000ff980000, 0x0000000100000000, 0x0000000100000000)

eden space 4608K, 94% used [0x00000000ff980000,0x00000000ffdc4e70,0x00000000ffe00000)

from space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)

to space 1024K, 0% used [0x00000000fff00000,0x00000000fff00000,0x0000000100000000)

ParOldGen total 7680K, used 638K [0x00000000fec00000, 0x00000000ff380000, 0x00000000ff980000)

object space 7680K, 8% used [0x00000000fec00000,0x00000000fec9fa38,0x00000000ff380000)

Metaspace used 3239K, capacity 4500K, committed 4864K, reserved 1056768K

class space used 351K, capacity 388K, committed 512K, reserved 1048576K

Process finished with exit code 0

木匠小强
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java：强引用、软引用、弱引用与虚引用
流楚丶格念的博客
07-27 1393
1、Java四种引用级别强引用、软引用、弱引用和虚引用。（由高到低）当垃圾回收器回收时，某些对象会被回收，某些不会被回收。垃圾回收器会从根对象Object来标记存活的对象，然后将某些不可达的对象和一些引用的对象进行回收。引用类型被垃圾回收时间用途生存时间强引用从来不会对象的一般状态JVM停止运行时终止软引用当内存不足时对象缓存内存不足（OOM）时终止弱引用正常垃圾回收时对象缓存垃圾回收（GC）后终止虚引用任何时候都可能跟踪对象的垃圾回收（因为有通知）https。......
【Android面试八股文】Java中有几种引用关系，它们的区别是什么？
字节卷动
06-16 61
强引用：默认的引用类型，对象不会被垃圾回收。软引用：在内存不足时回收，适合做缓存。弱引用：在垃圾回收时总会被回收，适合做内存敏感的数据结构。虚引用：不能直接访问对象，通过引用队列追踪对象的回收，用于清理或监控资源。每种引用类型在不同场景下有不同的用途，通过合理选择引用类型，可以有效管理内存和资源。
java之弱引用
dhpphd的博客
03-04 841
我们从三个维度去理解什么是弱引用   1.什么是弱引用 Java中的弱引用具体指的是java.lang.ref.WeakReference< T>类，我们首先来看一下官方文档对它做的说明： 弱引用对象的存在不会阻止它所指向的对象变被垃圾回收器回收。弱引用最常见的用途是实现规范映射(canonicalizing mappings，比如哈希表）。 假设垃圾收集器在某个时间点决定一个对象是弱可达的(weakly reachable)（也就是说当前指向它的全都是弱引用），这时垃圾收集器会清除所有指向
java List是强引用吗,经典面试题：强引用、软引用、弱引用、虚引用有什么区别？...
weixin_35750483的博客
03-13 281
原标题：经典面试题：强引用、软引用、弱引用、虚引用有什么区别？ 大家好，这里是java研究所。今天给大家带来一道经典面试题： 强引用、软引用、弱引用、虚引用有什么区别？众所周知，Java中是JVM负责内存的分配和回收，这是它的优点(使用方便，程序不用再像使用c那样操心内存)，但同时也是它的缺点(不够灵活)。为了解决内存操作不灵活这个问题，可以采用软引用等方法。在JDK1.2以前的版本中，当一个对象...
java 弱引用 集合_Java中的弱引用
weixin_30697437的博客
02-16 249
Strong referencesStringBuffer buffer = new StringBuffer();普通的对象创建都是这种类型，只要buffer还存在，对象就不会被GC回收。同时也会造成一定的问题，比如：向HashMap添加这些对象的句柄时，保存一个图片的缓存的时候，他们都不会自动清除Weak referencesReferenceQueue wrq = new Reference...
java List是强引用吗_Java中的四种引用类型：强引用、软引用、弱引用和虚引用...
weixin_39784263的博客
02-24 312
在Java中是由JVM负责内存的分配和回收，这是它的优点(简化编程者的工作，不需要像C语言那样去手动操作内存)，但同时也是它的缺点(不够灵活，垃圾回收对于编程者来说是不可控的)。在JDK1.2以前，如果一个对象不被任何变量引用，则程序无法再次使用这个对象，这个对象最终会被GC(GabageCollection：垃圾回收)。但是如果之后可能还会用到这个对象，就只能去新建一个了，这其实就降低了JVM性...
Java的引用、软引用和弱引用
a331365046的专栏
05-30 958
Java的引用     Object  obj
详解JAVA 强引用
08-18
JAVA 强引用详解 ...2. 静态集合类对象持有强引用：public static ArrayList<Object> list = new ArrayList(); 强引用是JAVA 中最基本的引用类型，我们需要正确地使用强引用，避免内存泄漏和OOM。
使用Java强引用和垃圾回收实现一个简单的缓存系统.txt
08-17
在Java中，对象的引用分为四种不同的类型：强引用、软引用、弱引用和虚引用。本示例中主要关注的是强引用。强引用是最常用的引用类型，它通过直接保存对象实例的方式来保持对对象的访问。只要强引用存在，垃圾收集器...
【Android面试八股文】1. 说一说Java四大引用有哪些？ 2. 软引用和弱引用的区别是什么？
最新发布
字节卷动
07-15 1158
强引用是最常见的引用类型，它决定了对象的生命周期。软引用用来实现缓存，对内存敏感的对象，当内存不足时可以被回收。弱引用用来实现弱关联，当没有强引用指向对象时，即使有弱引用指向它，也可以被垃圾回收器回收。虚引用主要用来跟踪对象被回收的状态，在对象被回收时收到系统通知，用于执行一些必要的清理操作。这些引用类型提供了灵活的内存管理机制，可以根据实际需求选择合适的引用类型来优化程序的性能和内存使用。回收时机：软引用是在系统内存不足时才被回收，而弱引用则是在下一次垃圾回收时被回收。适用场景。
【Java引用规范】弱引用
Azir_的博客
01-22 686
在上一节，我们介绍了强软引用。在这期，从内存变动趋势图以及内存快照中研究GC怎么特殊处理弱引用的。
java List是强引用吗,Java基础｜强引用、弱引用、软引用、虚引用
weixin_42180863的博客
03-13 324
前言在ThreadLocal源码中，其中嵌套类ThreadLocalMap中的Entry继承了WeakReferenc。Java中提供这四种引用类型主要有两个目的：第一是可以让程序员通过代码的方式决定某些对象的生命周期;第二是有利于JVM进行垃圾回收。强引用(StrongReference)强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。如下：Objecto=new...
Java的四种引用方式(强引用，软引用，弱引用，虚引用)
wenhuabuzhijian的博客
08-09 936
文章目录前言一、强引用（StrongReference）二、软引用（SoftReference）三、弱引用（WeakReference）四、虚引用（PhantomReference）总结 前言 众所周知，Java中是JVM负责内存的分配和回收，这是它的优点（使用方便，程序不用再像使用c那样操心内存），但同时也是它的缺点（不够灵活）。为了解决内存操作不灵活这个问题，可以采用软引用等方法。 在JDK1.2以前的版本中，当一个对象不被任何变量引用，那么程序就无法再使用这个对象。从JDK1.2版本开始，把对象的引
弱引用总结及HashMap、List弱引用并Lru实现
开发笔记
06-21 3250
Reference C++中有指针和Reference的概念，指针可以重新赋值，而Reference只能初始化时赋值。 然而，java中的Reference是可以重新赋值，并不是C++的Reference概念，类似于C++的指针的概念。 WeakReference和Strong Reference 通常实例化的操作就是强引用： Object obj = new Object();
java list内存分配_java 循环list.add(对象),这两种方法在jvm都是怎么分配堆栈内存的？...
weixin_36162235的博客
02-16 809
先看一下两种的字节码表示(只截取了循环体的部分)：第一种：one变量声明在循环体之外第二种：one变量声明在循环体内部第二种方法会在栈开辟10个空间存引用地址，在堆开辟10个空间存实际内容。这种说法是错误的。aload_n指令表示加载栈帧局部变量表偏移量为n的变量；astore_n反之，表示存储[1]。对比源码和字节码可以看出，在第二种方法中，one只在栈中开辟了一个空间，位于局部变量表下标为3的...
Java强引用、弱引用及举例
Yisnow.的博客
08-26 639
1、强引用 当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。 String str = "abc"; List<String> list = new Arraylist<String>(); list.add(str);123 在list集合里的数据不会释放，即使内存不足也不会 在ArrayList类中定义了一个私有的变量elementData数组，在调用方法清空数组时可以看到为每
java 弱引用 集合,java 强引用，软引用，弱引用，虚引用
weixin_35018103的博客
03-14 131
强引用(StrongReference)强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。我们平常使用的大多数是强引用。软引用(SoftReference)如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内...
java 中 遍历 list 与 遍历 map
mhbsoft的博客
02-18 301
遍历 list public class Test{ public static void main(String[] args) { List<String> list=new ArrayList<String>(); list.add("Hello"); list.add("World"); list.add("HAHAHAHA...
java 软引用 使用_你不可不知的Java引用类型之——软引用
weixin_40002846的博客
02-16 314
定义软引用是使用SoftReference创建的引用，强度弱于强引用，被其引用的对象在内存不足的时候会被回收，不会产生内存溢出。说明软引用，顾名思义就是比较“软”一点的引用。当一个对象与GC Roots之间存在强引用时，无论何时都不会被GC回收掉。如果一个对象与GC Roots之间没有强引用与其关联而存在软引用关联时，那么垃圾回收器对它的态度就取决于内存的紧张程度了。如果内存空间足够，垃圾回收器就...
Java基础全面解析：面向对象、JVM等核心知识点
26. **Java中引用**： 了解引用类型（如对象、数组）的生命周期和引用传递方式，有助于理解内存管理和效率。 这些知识点涵盖了Java编程的基础架构，对于理解和使用Java语言至关重要。学习和掌握它们将有助于构建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值