Reference是java中的特殊引用类。描述的是特殊作用(主要是关于垃圾回收对象)的引用。

它有3个子类:

1.SoftReference;

2.WeakReference

3.PhantomReference

先看thinking in java 中的实例

package containers;

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.util.LinkedList; //对引用的 描述与封装,Reference类 class VeryBig2{
private static final int SIZE= 10000;
private long[] la= new long[SIZE];
private String ident;
public VeryBig2(String id){
ident= id;
}
@Override
public String toString() { return ident;
}
protected void finalize(){
System.out.println("Finalizing "+ ident);
}
} public class ReferencesTest {
private static ReferenceQueue<VeryBig2> rq=
new ReferenceQueue<VeryBig2>();
public static void checkQueue(){
Reference<? extends VeryBig2> inq= rq.poll();
if (inq != null) {
System.out.println("In queue: "+ inq.get());
}
} public static void main(String[] args) {
int size= 10;
if (args.length> 0) {
size= new Integer(args[0]);
}
LinkedList<SoftReference<VeryBig2>> sa=
new LinkedList<SoftReference<VeryBig2>>();
for (int i = 0; i < size; i++) {
sa.add(new SoftReference<VeryBig2>(new VeryBig2("Soft "+ i), rq));
System.out.println("Just created: "+ sa.getLast());
checkQueue();
} LinkedList<WeakReference<VeryBig2>> wa=
new LinkedList<WeakReference<VeryBig2>>();
for (int i = 0; i < size; i++) {
wa.add(new WeakReference<VeryBig2>(new VeryBig2("Weak "+ i), rq));
System.out.println("Just created: "+ wa.getLast());
checkQueue();
} SoftReference<VeryBig2> s=
new SoftReference<VeryBig2>(new VeryBig2("Soft"));
WeakReference<VeryBig2> w=
new WeakReference<VeryBig2>(new VeryBig2("Weak"));
System.gc();//对无引用的对象,执行垃圾回收操作。并且,调用回收对象的finalize方法 LinkedList<PhantomReference<VeryBig2>> pa=
new LinkedList<PhantomReference<VeryBig2>>();
for (int i = 0; i < size; i++) {
pa.add(new PhantomReference<VeryBig2>(new VeryBig2("Phantom "+ i), rq));
System.out.println("Just created: "+ pa.getLast());
checkQueue();
}
}
}

output:

Just created: java.lang.ref.SoftReference@2a9931f5
Just created: java.lang.ref.SoftReference@2f9ee1ac
Just created: java.lang.ref.SoftReference@67f1fba0
Just created: java.lang.ref.SoftReference@3fbefab0
Just created: java.lang.ref.SoftReference@133c5982
Just created: java.lang.ref.SoftReference@5f186fab
Just created: java.lang.ref.SoftReference@3d4b7453
Just created: java.lang.ref.SoftReference@24c21495
Just created: java.lang.ref.SoftReference@41d5550d
Just created: java.lang.ref.SoftReference@1cc2ea3f
Just created: java.lang.ref.WeakReference@40a0dcd9
Just created: java.lang.ref.WeakReference@1034bb5
Just created: java.lang.ref.WeakReference@7f5f5897
Just created: java.lang.ref.WeakReference@4cb162d5
Just created: java.lang.ref.WeakReference@11cfb549
Just created: java.lang.ref.WeakReference@5b86d4c1
Just created: java.lang.ref.WeakReference@70f9f9d8
Just created: java.lang.ref.WeakReference@2b820dda
Just created: java.lang.ref.WeakReference@675b7986
Just created: java.lang.ref.WeakReference@2687816d
Just created: java.lang.ref.PhantomReference@7b11a3ac
In queue: null
Just created: java.lang.ref.PhantomReference@7ca83b8a
In queue: null
Finalizing Weak
Just created: java.lang.ref.PhantomReference@8dd20f6
In queue: null
Just created: java.lang.ref.PhantomReference@6d9efb05
In queue: null
Just created: java.lang.ref.PhantomReference@60723d7c
In queue: null
Just created: java.lang.ref.PhantomReference@6c22c95b
In queue: null
Just created: java.lang.ref.PhantomReference@5fd1acd3
In queue: null
Just created: java.lang.ref.PhantomReference@3ea981ca
In queue: null
Finalizing Weak 9
Just created: java.lang.ref.PhantomReference@6a8814e9
In queue: null
Finalizing Weak 8
Finalizing Weak 7
Just created: java.lang.ref.PhantomReference@c1503a3
In queue: null
Finalizing Weak 6
Finalizing Weak 5
Finalizing Weak 4
Finalizing Weak 3

从结果中,可以看出:

1.垃圾回收器回收优先级别:SoftReference< WeakReference < PhantomReference。

2.当运行垃圾回收方法System.gc时,会先调用目标对象的finalize方法。

3.当某个对象实例 ,只被Reference(包括上面三个派生类)引用的时候,在垃圾回收器回收的时候,被回收。

若这个实例,被Reference和普通引用 同时引用,那么 按照普通引用的垃圾回收规则来,不被回收。

普通引用的垃圾回收规则:

若某对象实例被普通引用 引用(即此对象是可获得的,参考thinking in java的解释),那么不会被垃圾回收器回收。

若某对象实例不被任何普通引用 引用(即此对象是不可获得的,参考thinking in java的解释),那么会被垃圾回收器回收。

参见下面的代码:(摘自thinking in java4ed)

package containers;

import java.util.WeakHashMap;

class Element{
private String ident;
public Element(String id){
ident = id;
}
public String toString(){
return ident;
}
public int hashCode(){
return ident.hashCode();
}
public boolean equals(Object r){
return r instanceof Element && ident.equals(((Element)r).ident);//此处应有掌声
} protected void finalize(){
System.out.println("Finalizing "+ getClass().getSimpleName()+ " "
+ ident);
}
} class Key extends Element{
public Key(String id){
super(id);
}
} class Value extends Element{
public Value(String id){
super(id);
}
} public class CanonicalMapping {
public static void main(String[] args) {
int size= 1000;
if (args.length >0) {
size= new Integer(args[0]);
}
Key[] keys= new Key[size];
WeakHashMap<Key, Value> map= new WeakHashMap<Key, Value>();
for (int i = 0; i < size; i++) {
Key k= new Key(Integer.toString(i));//Key的实例被普通引用k引用
Value v= new Value(Integer.toString(i));//Value的实例被普通引用v引用
if (i % 3 ==0) {
keys[i]= k;//Key的实例被普通引用keys[i]引用,这时,一个Key的实例既被k引用,也被keys[i]引用。
}
map.put(k, v);//k引用,v引用自动被WeakHashMap封装为WeakReference引用。
}
System.gc();//垃圾回收的时候,对于对象实例(Key的实例和Value的实例)只被Reference(WeakReference)引用的时候,被回收。
//如果这个实例既被Reference引用,也被普通引用引用,则按照普通引用垃圾回收规则来, 不被回收
}
}

thinking in java 之Reference类的使用的更多相关文章

  1. Java基本功—Reference

    这是一篇一年多之前便已写就的文章,那时,因为很多Java程序员只求追随新生的事物,却连基本的概念都没有,很多讨论中,很明显是基本功不过硬,于是萌生写一个系列文章,讨论Java的基本功,下面便是在这个想 ...

  2. AJPFX总结java开发常用类(包装,数字处理集合等)(一)

    一:首谈java中的包装类 Java为基本类型提供包装类,这使得任何接受对象的操作也可以用来操作基本类型,直接将简单类型的变量表示为一个类,在执行变量类型的相互转换时,我们会大量使用这些包装类.jav ...

  3. Java中Object类hashCode的底层实现

    Java中Object类hashCode的底层实现 openjdk\jdk\src\share\native\java\lang\Object.c 42 static JNINativeMethod ...

  4. Java的String类详解

    Java的String类 String类是除了Java的基本类型之外用的最多的类, 甚至用的比基本类型还多. 同样jdk中对Java类也有很多的优化 类的定义 public final class S ...

  5. java.lang.Void类源码解析_java - JAVA

    文章来源:嗨学网 敏而好学论坛www.piaodoo.com 欢迎大家相互学习 在一次源码查看ThreadGroup的时候,看到一段代码,为以下: /* * @throws NullPointerEx ...

  6. java自定义注解类

    一.前言 今天阅读帆哥代码的时候,看到了之前没有见过的新东西, 比如java自定义注解类,如何获取注解,如何反射内部类,this$0是什么意思? 于是乎,学习并整理了一下. 二.代码示例 import ...

  7. 基础知识(05) -- Java中的类

    Java中的类 1.类的概念 2.类中的封装 3.对象的三大特征 4.对象状态 5.类与类之间的关系 ------------------------------------------------- ...

  8. java中Inetaddress类

    InetAddress类 InetAddress类用来封装我们前面讨论的数字式的IP地址和该地址的域名. 你通过一个IP主机名与这个类发生作用,IP主机名比它的IP地址用起来更简便更容易理解. Ine ...

  9. Java集合---Array类源码解析

    Java集合---Array类源码解析              ---转自:牛奶.不加糖 一.Arrays.sort()数组排序 Java Arrays中提供了对所有类型的排序.其中主要分为Prim ...

随机推荐

  1. Codeforces Round #197 (Div. 2)

    A.Helpful Maths 分析:将读入的字符转化为数字,直接排个序就可以了. #include <cstdlib> #include <cstring> #include ...

  2. iOS - OC 异常处理

    1.@try 语句 @try { // Code that can potentially throw an exception 可能会抛出异常的代码块 statement . . . } @catc ...

  3. alloc && afree

    #define ALLOCSIZE 10000 static char allocbuf[ALLOCSIZE]; static char *allocp = allocbuf; char *alloc ...

  4. springmvc:frameServletBean

    1.httpservlerBean 主要初始化web.xml的init-param参数 2.frameWorkServlet 该类作用 1.applicationConetxt用于配置整体 webap ...

  5. default(T)的含义

    default(T)是泛型中初始化的用法.因为对于泛型T你不知道是值类型还是引用类型,所以传参数是可能会出错.这里就要用到default(T). T t=default(T),就是初始化,值类型的话, ...

  6. Python学习笔记--XML的应用

    XML的定义 XML 指可扩展标记语言(EXtensible Markup Language) XML 是一种标记语言,很类似 HTML XML 的设计宗旨是传输数据,而非显示数据 XML 标签没有被 ...

  7. js-------》(小效果)实现倒计时及时间对象

    js实现倒计时及时间对象 JS实现倒计时效果代码如下: 1 <!doctype html> 2 <html> 3 <head> 4 <meta charset ...

  8. unsigned 整型实现无溢出运算

    普通的 int 整型能表示的范围很有限,所以刷题时很多时候不得不用 long long 来存更大的数据.或者找出数列中某个只出现一次(或奇数次)的数(其余的数均出现两次 / 偶数次),用异或运算的经典 ...

  9. 如何让JS的变量名变量化

    unction message() { var k=0; // var olk+k="sdasdasd"; eval("var olk"+k+"='a ...

  10. XMLHttpRequest cannot load – Origin is not allowed by Access-Control-Allow-Origin.

    报错:跨域  XMLHttpRequest cannot load http://localhost:8080/yxt-admin/admin/store. No 'Access-Control-Al ...