java强引用,软引用,弱引用,虚引用
java强引用,软引用,弱引用,虚引用
原文:https://blog.csdn.net/liaodehong/article/details/52223354
用了Java怎么长时间一直不知道原来Java还有四种引用类型,这个引用类型和我们平常说的可不一样。这里的引用类型不是指数据类型的一种,而是指Java中的引用所分的四种类型。他们代表了JVM回收内存的四种强度,分别如下。
强引用:
Java中的引用,有点像C++的指针。通过引用,可以对堆中的对象进行操作。在某函数中,当创建了一个对象,该对象被分配在堆中,通过这个对象的引用才能对这个对象进行操作。
Object o = new Object();
假设以上代码是在函数体内运行的,那么局部变量o将被分配在栈上,而对象实例,被分配在堆上。局部变量o指向Object实例所在的堆空间,通过o可以操作该实例,那么o就是Object的引用。
如果再创建一个赋值语句
Object oj = o;
那么o指向的Object内存空间也会被oj所指向,此时我们可以说oj==o,那么ob.equals也肯定相等,即两个对象的值也肯定一样,当修改了o对象的时候,oj对象也会发生变化,或者当修改了oj对象的时候o对象也肯定会变化。所以如果想复制另外一个对象的值的话千万不要用这种方式,在多线程的情况下可能会有更槽糕的情况发生,你可以使用JDK自带的克隆方法,也可以重写克隆方法。
public class Test1 {
public static void main(String[] args) {
student S=new student("1","我是大s");
student s=S;
System.out.println(s==S); //true
System.out.println(s.equals(S)); //true
System.out.println("打印出大S"+S); //id=1
System.out.println("打印出小s"+s); //id=1
S.setId("2");
System.out.println("修改后的大S"+S); //id=2
System.out.println("未修改后的小s"+s); //id=2
s.setId("3");
System.out.println("未修改后的大S"+S); //id=3
System.out.println("修改后的小s"+s); //id=3 }
}
class student{
String name;
String id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public student(String name, String id) {
super();
this.name = name;
this.id = id;
}
@Override
public String toString() {
return "student [name=" + name + ", id=" + id + "]";
} }
上例中的大S和小S都是强引用,强引用具有如下特点:
1.强引用可以直接访问目标对象。
2.强引用所指向的对象在任何时候都不会被系统回收。JVM宁愿抛出OOM异常,也不会回收强引用所指向的对象。
3.强引用可能导致内存泄漏,为了避免内存泄漏,在使用完成之后我们可以把字符串对象设置为null,如果是集合的话可以使用
List list=new ArrayList<>();
list.clear();
软引用:
软引用的强度是仅次于强引用的,如果一个对象只具有软引用,则内存空间足够,垃圾回收器就不会回收它;如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。
我们可以使用java.lang.ref.SoftReference来创建软引用;
String str=new String("abc"); // 强引用
SoftReference<String> softRef=new SoftReference<String>(str); // 软引用
当内存不足时,等价于:
If(JVM.内存不足()) {
str = null; // 转换为空引用
System.gc(); // 垃圾回收器进行回收
}
弱引用:
弱引用的强度比软引用更次,也就是说只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。
如果这个对象是偶尔的使用,并且希望在使用时随时就能获取到,但又不想影响此对象的垃圾收集,那么你应该用 Weak Reference 来标记此对象。
String str=new String("abc");
WeakReference<String> abcWeakRef = new WeakReference<String>(str);
str=null;
如果你想把这个对象变成强引用的话可以使用
String abc = abcWeakRef.get();
弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
当你想引用一个对象,但是这个对象有自己的生命周期,你不想介入这个对象的生命周期,这时候你就是用弱引用。
这个引用不会在对象的垃圾回收判断中产生任何附加的影响。
public class ReferenceTest { private static ReferenceQueue<VeryBig> rq = new ReferenceQueue<VeryBig>(); public static void checkQueue() {
Reference<? extends VeryBig> ref = null;
while ((ref = rq.poll()) != null) {
if (ref != null) {
System.out.println("In queue: " + ((VeryBigWeakReference) (ref)).id);
}
}
} public static void main(String args[]) {
int size = 3;
LinkedList<WeakReference<VeryBig>> weakList = new LinkedList<WeakReference<VeryBig>>();
for (int i = 0; i < size; i++) {
weakList.add(new VeryBigWeakReference(new VeryBig("Weak " + i), rq));
System.out.println("Just created weak: " + weakList.getLast()); } System.gc();
try { // 下面休息几分钟,让上面的垃圾回收线程运行完成
Thread.currentThread().sleep(6000);
} catch (InterruptedException e) {
e.printStackTrace();
}
checkQueue();
}
} class VeryBig {
public String id;
// 占用空间,让线程进行回收
byte[] b = new byte[2 * 1024]; public VeryBig(String id) {
this.id = id;
} protected void finalize() {
System.out.println("Finalizing VeryBig " + id);
}
} class VeryBigWeakReference extends WeakReference<VeryBig> {
public String id; public VeryBigWeakReference(VeryBig big, ReferenceQueue<VeryBig> rq) {
super(big, rq);
this.id = big.id;
} protected void finalize() {
System.out.println("Finalizing VeryBigWeakReference " + id);
}
}
虚引用
虚引用顾名思义就是形同虚设,虚引用也称为幻影引用:一个对象是都有虚引用的存在都不会对生存时间都构成影响,也无法通过虚引用来获取对一个对象的真实引用。唯一的用处:能在对象被GC时收到系统通知,JAVA中用PhantomReference来实现虚引用。
对比不同:
import java.lang.ref.Reference;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.util.Set;
import java.util.HashSet; class Grocery {
private static final int SIZE = 10000;
// 属性d使得每个Grocery对象占用较多内存,有80K左右
private double[] d = new double[SIZE];
private String id;
public Grocery(String id) {
this.id = id;
}
public String toString() {
return id;
}
/* public void finalize() { // 注意: finalize 在 Java 11 中已经被废弃
System.out.println("即将回收 " + id);
} */
} public class HelloWorld { // 关联的引用队列 如果引用的对象被JVM回收 则这个引用就会被加入到与之关联的引用队列中
private static ReferenceQueue<Grocery> rq = new ReferenceQueue<Grocery>(); public static void checkQueue() { boolean flag = true;
System.out.println(">>>>>>>>>>>>>>>>>>>>");
while (flag) {
Reference<? extends Grocery> inq = rq.poll(); // 从队列中取出一个引用
if (inq != null) {
flag = true;
System.out.println("In queue: type ===> " + inq + " value ===> " + inq.get());
} else {
flag = false;
System.out.println("In queue: " + "is null");
}
}
System.out.println("<<<<<<<<<<<<<<<<<<<");
} public static void main(String[] args) {
// 引用创建的固定数量
final int size = 10; // 创建10个Grocery对象以及10个软引用
Set<SoftReference<Grocery>> sa = new HashSet<SoftReference<Grocery>>();
for (int i = 0; i < size; i++) {
SoftReference<Grocery> ref = new SoftReference<Grocery>(
new Grocery("SoftReference " + i), rq);
System.out.println("刚刚 创建了 软引用: " + ref.get());
sa.add(ref);
}
System.gc();
checkQueue(); // 创建10个Grocery对象以及10个弱引用
Set<WeakReference<Grocery>> wa = new HashSet<WeakReference<Grocery>>();
for (int i = 0; i < size; i++) {
WeakReference<Grocery> ref = new WeakReference<Grocery>(
new Grocery("WeakReference " + i), rq);
System.out.println("刚刚 创建了 弱引用: " + ref.get());
wa.add(ref);
}
System.gc();
checkQueue(); // 创建10个Grocery对象以及10个虚引用
Set<PhantomReference<Grocery>> pa = new HashSet<PhantomReference<Grocery>>();
for (int i = 0; i < size; i++) {
PhantomReference<Grocery> ref = new PhantomReference<Grocery>(
new Grocery("PhantomReference " + i), rq);
System.out.println("刚刚 创建了 虚引用 : " + ref.get());
pa.add(ref);
}
System.gc();
checkQueue();
}
}
控制台输出
>javac -encoding utf-8 -d .\src .\src\HelloWorld.java
>java -Dfile.encoding=utf-8 -cp .\src HelloWorld
刚刚 创建了 软引用: SoftReference 0
刚刚 创建了 软引用: SoftReference 1
刚刚 创建了 软引用: SoftReference 2
刚刚 创建了 软引用: SoftReference 3
刚刚 创建了 软引用: SoftReference 4
刚刚 创建了 软引用: SoftReference 5
刚刚 创建了 软引用: SoftReference 6
刚刚 创建了 软引用: SoftReference 7
刚刚 创建了 软引用: SoftReference 8
刚刚 创建了 软引用: SoftReference 9
>>>>>>>>>>>>>>>>>>>>
In queue: is null
<<<<<<<<<<<<<<<<<<<
刚刚 创建了 弱引用: WeakReference 0
刚刚 创建了 弱引用: WeakReference 1
刚刚 创建了 弱引用: WeakReference 2
刚刚 创建了 弱引用: WeakReference 3
刚刚 创建了 弱引用: WeakReference 4
刚刚 创建了 弱引用: WeakReference 5
刚刚 创建了 弱引用: WeakReference 6
刚刚 创建了 弱引用: WeakReference 7
刚刚 创建了 弱引用: WeakReference 8
刚刚 创建了 弱引用: WeakReference 9
>>>>>>>>>>>>>>>>>>>>
In queue: type ===> java.lang.ref.WeakReference@de0a01f value ===> null
In queue: type ===> java.lang.ref.WeakReference@ba4d54 value ===> null
In queue: type ===> java.lang.ref.WeakReference@4c75cab9 value ===> null
In queue: type ===> java.lang.ref.WeakReference@6aceb1a5 value ===> null
In queue: type ===> java.lang.ref.WeakReference@769c9116 value ===> null
In queue: type ===> java.lang.ref.WeakReference@1ef7fe8e value ===> null
In queue: type ===> java.lang.ref.WeakReference@12bc6874 value ===> null
In queue: type ===> java.lang.ref.WeakReference@2d6d8735 value ===> null
In queue: type ===> java.lang.ref.WeakReference@67117f44 value ===> null
In queue: type ===> java.lang.ref.WeakReference@6f79caec value ===> null
In queue: is null
<<<<<<<<<<<<<<<<<<<
刚刚 创建了 虚引用 : null
刚刚 创建了 虚引用 : null
刚刚 创建了 虚引用 : null
刚刚 创建了 虚引用 : null
刚刚 创建了 虚引用 : null
刚刚 创建了 虚引用 : null
刚刚 创建了 虚引用 : null
刚刚 创建了 虚引用 : null
刚刚 创建了 虚引用 : null
刚刚 创建了 虚引用 : null
>>>>>>>>>>>>>>>>>>>>
In queue: type ===> java.lang.ref.PhantomReference@2cfb4a64 value ===> null
In queue: type ===> java.lang.ref.PhantomReference@5474c6c value ===> null
In queue: type ===> java.lang.ref.PhantomReference@7a92922 value ===> null
In queue: type ===> java.lang.ref.PhantomReference@483bf400 value ===> null
In queue: type ===> java.lang.ref.PhantomReference@71f2a7d5 value ===> null
In queue: type ===> java.lang.ref.PhantomReference@4b6995df value ===> null
In queue: type ===> java.lang.ref.PhantomReference@21a06946 value ===> null
In queue: type ===> java.lang.ref.PhantomReference@326de728 value ===> null
In queue: type ===> java.lang.ref.PhantomReference@77f03bb1 value ===> null
In queue: type ===> java.lang.ref.PhantomReference@25618e91 value ===> null
In queue: is null
<<<<<<<<<<<<<<<<<<<
在上面的这个例子中,依次创建了十个10个软引用、10个弱引用和10个虚引用,它们各自引用一个Grocery对象。并且在创建之后调用GC方法。从程序运行时的打印结果可以看出,虚引用形同虚设,它所引用的对象随时可能被垃圾回收,具有弱引用的对象拥有稍微长的生命周期,当垃圾回收器执行回收操作时,有可能被垃圾回收,具有软引用的对象拥有较长的生命周期,但在Java虚拟机认为内存不足的情况下,也会被垃圾回收。
总结
强引用:就像是老板(OOM)的亲儿子一样,在公司可以什么事都不干,但是千万不要老是占用公司的资源为他自己做事,记得用完公司的妹子之后,要让她们去工作(资源要懂得释放) 不然公司很可能会垮掉的。
软引用:有点像老板(OOM)的亲戚,在公司表现不好有可能会被开除,即使你投诉他(调用GC)上班看片,但是只要不被老板看到(被JVM检测到)就不会被开除(被虚拟机回收)。
弱引用:就是一个普通的员工,平常如果表现不佳会被开除(对象没有其他引用的情况下),遇到别人投诉(调用GC)上班看片,那开除是肯定了(被虚拟机回收)。
虚引用:这货估计就是个实习生跟临时工把,遇到事情的时候想到了你,没有事情的时候,秒秒钟拿出去顶锅,开除。
================= End
java强引用,软引用,弱引用,虚引用的更多相关文章
- 0030 Java学习笔记-面向对象-垃圾回收、(强、软、弱、虚)引用
垃圾回收特点 垃圾:程序运行过程中,会为对象.数组等分配内存,运行过程中或结束后,这些对象可能就没用了,没有变量再指向它们,这时候,它们就成了垃圾,等着垃圾回收程序的回收再利用 Java的垃圾回收机制 ...
- Java:对象的强、软、弱、虚引用
转自: http://zhangjunhd.blog.51cto.com/113473/53092 1.对象的强.软.弱和虚引用 在JDK 1.2以前的版本中,若一个对象不被任何变量引用,那么程序就无 ...
- Java中四种引用:强、软、弱、虚引用
这篇文章非常棒:http://alinazh.blog.51cto.com/5459270/1276173 Java中四种引用:强.软.弱.虚引用 1.1.强引用当我们使用new 这个关键字创建对象时 ...
- Java:对象的强、软、弱和虚引用
1.对象的强.软.弱和虚引用 在JDK 1.2以前的版本中,若一个对象不被任何变量引用,那么程序就无法再使用这个对象.也就是说,只有对象处于可触及(reachable)状态,程序才能使用它.从JDK ...
- Java对象的强、软、弱和虚引用详解
1.对象的强.软.弱和虚引用 转自:http://zhangjunhd.blog.51cto.com/113473/53092/ 在JDK 1.2以前的版本中,若一个对象不被任何变量引用,那么程序就无 ...
- java基础知识再学习--集合框架-对象的强、软、弱和虚引用
原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 .作者信息和本声明.否则将追究法律责任.http://zhangjunhd.blog.51cto.com/113473/53092 本文 ...
- Java对象的强、软、弱和虚引用原理+结合ReferenceQueue对象构造Java对象的高速缓存器
//转 http://blog.csdn.net/lyfi01/article/details/6415726 1.Java对象的强.软.弱和虚引用 在JDK 1.2以前的版本中,若一个对象不被任何变 ...
- Java:对象的强、软、弱和虚引用[转]
原文链接:http://zhangjunhd.blog.51cto.com/113473/53092/ 原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 .作者信息和本声明.否则将追究法 ...
- Java对象的强、软、弱和虚引用+ReferenceQueue
Java对象的强.软.弱和虚引用+ReferenceQueue 一.强引用(StrongReference) 强引用是使用最普遍的引用.如果一个对象具有强引用,那垃圾回收器绝不会回收它.当内存空间不足 ...
- Java:对象的强、软、弱和虚引用的区别
1.对象的强.软.弱和虚引用 在JDK 1.2以前的版本中,若一个对象不被任何变量引用,那么程序就无法再使用这个对象.也就是说,只有对象处于可触及(reachable)状态,程序才能使用它.从JDK ...
随机推荐
- EF 利用PagedList进行分页并结合查询 方法2
微软提供了PagedList分页,相信大家在网上也能搜索一大堆关于pagedList用法的博客,论坛.但是,在使用的过程中一不小心,就会掉入pagedList某种常规用法的陷阱. 我所说的某种常规用法 ...
- (11)学习笔记 ) ASP.NET CORE微服务 Micro-Service ---- Thrift高效通讯 (完结)
一. 什么是 RPC Restful 采用 Http 进行通讯,优点是开放.标准.简单.兼容性升级容易: 缺点是性能略低.在 QPS 高或者对响应时间要求苛刻的服务上,可以用 RPC(Remote P ...
- Zabbix监控系统部署:源码安装
1. 概述1.1 基础环境2. 部署过程2.1 创建用户组2.2 下载源码解压编译安装2.2.1 下载源码解压2.2.2 YUM安装依赖环境2.2.3 编译安装最新版curl2.2.4 更新GNU构建 ...
- c#基础系列1---深入理解值类型和引用类型
"大菜":源于自己刚踏入猿途混沌拾起,自我感觉不是一般的菜,因而得名"大菜",于自身共勉. 不知不觉已经踏入坑已10余年之多,对于c#多多少少有一点自己的认识, ...
- css3 动画效果实现
前沿 在工作中,经常有一些需要切换的交互样式.如果直接在两种状态之间切换,就显得有点生硬.加上一些动画效果就会好很多. 示例1:点击的三角切换 实现过程 第一步实现这个三角形 用的svg 的多边形画法 ...
- oracle加注释
COMMENT ON table GC_G_DOC84 IS '行政处罚撤销决定书'; COMMENT ON column GC_G_DOC84.CASEID IS '案件记录ID';
- 3-Python3从入门到实战—基础之数据类型(数字-Number)
Python从入门到实战系列--目录 Python3 中有六个标准的数据类型: Number(数字) String(字符串) List(列表) Tuple(元组) Sets(集合) Dictionar ...
- ES6.0简单了解
Case 1:let.const var的缺陷 1.可以重复声明变量 2.无法限制修改(没有常量) 3.没有块级作用域 let和const可以弥补var的缺陷 let: 不能重复声明,用来声明变量,声 ...
- shell脚本--shift参数左移
参数左移什么意思呢?这个参数指的是在运行脚本时,跟在脚本名后面的参数,前面已经讲过,可以使用$#来获取参数的个数,使用$*来获取所有的参数,而参数左移的含义是这样的:有个指针指向参数列表第一个参数,左 ...
- CentOS(6.8)7 安装 Mysql 5.7
https://blog.csdn.net/zyw_java/article/details/70949596 https://blog.csdn.net/yzl11/article/details/ ...