Java 中的引用类型

Java 中的引用类型?

除了8大基本数据类型(不包括void),其他都是引用类型.

可能面试官就是问的上面这个,但是如果你能补充下去,这会是一个很好的展现机会!

java中的引用类型分为4种:强,软,弱,虚!这中分类与GC有关,如果你对GC有一些了解的话,可以继续谈谈,如果不了解GC的话,建议适可而止..

1.对象的强、软、弱和虚引用

在JDK 1.2以前的版本中,若一个对象不被任何变量引用,那么程序就无法再使用这个对象。也就是说,只有对象处于可触及(reachable)状态,程序才能使用它。从JDK 1.2版本开始,把对象的引用分为4种级别,从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为:强引用、软引用、弱引用和虚引用。

1)强引用(StrongReference)
    强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。当内存空间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题。

2)软引用(SoftReference)
    如果一个对象只具有软引用,则内存空间足够,垃圾回收器就不会回收它;如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存
    软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收器回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

3) 弱引用(WeakReference)
    弱引用与软引用的区别在于:弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。
    弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

String str = new String("hello"); //--1--
 ReferenceQueue<String> rq = new ReferenceQueue<String>(); //--2--
 WeakReference<String> wf = new WeakReference<String>(str, rq); //--3--
 str=null; //--4--取消"hello"对象的强引用
 String str1=wf.get(); //--5--假如"hello"对象没有被回收,str1引用"hello"对象
//假如"hello"对象没有被回收,rq.poll()返回
null
 Reference<? extends String> ref=rq.poll(); //--6--

带实线的箭头表示强引用,带虚线的箭头表示弱引用。从图中可以看出,此时"hello"对象被str强引用,并且被一个WeakReference对象弱引用,因此"hello"对象不会被垃圾回收。
在以下程序代码中,把引用"hello"对象的str变量置为null,然后再通过WeakReference弱引用的get()方法获得"hello"对象的引用:

执行完以上第④行后,内存中引用与对象的关系如图11-11所示,此 时"hello"对象仅仅具有弱引用,因此它有可能被垃圾回收。假如它还没有被垃圾回收,那么接下来在第⑤行执行wf.get()方法会返回 "hello"对象的引用,并且使得这个对象被str1强引用。再接下来在第⑥行执行rq.poll()方法会返回null,因为此时引用队列中没有任何 引用。ReferenceQueue的poll()方法用于返回队列中的引用,如果没有则返回null。

在以下程序代码中,执行完第④行后,"hello"对象仅仅具有弱引用。接下来两次调用System.gc()方法,催促垃圾回收器工作,从而提高 "hello"对象被回收的可能性。假如"hello"对象被回收,那么WeakReference对象的引用被加入到ReferenceQueue中, 接下来wf.get()方法返回null,并且rq.poll()方法返回WeakReference对象的引用。图11-12显示了执行完第⑧行后内存 中引用与对象的关系。

String str = new String("hello"); //①
ReferenceQueue<String> rq = new ReferenceQueue<String>(); //② 
WeakReference<String> wf = new WeakReference<String>(str, rq); //③
str=null; //④
//两次催促垃圾回收器工作,提高"hello"对象被回收的可能性
System.gc(); //⑤
System.gc(); //⑥
String str1=wf.get(); //⑦ 假如"hello"对象被回收,str1为null
Reference<? extends String> ref=rq.poll(); //⑧

在以下例程11-15的References类中,依次创建了10个软引用、10个弱引用和10个虚引用,它们各自引用一个Grocery对象。从程序运 行时的打印结果可以看出,虚引用形同虚设,它所引用的对象随时可能被垃圾回收,具有弱引用的对象拥有稍微长的生命周期,当垃圾回收器执行回收操作时,有可 能被垃圾回收,具有软引用的对象拥有较长的生命周期,但在Java虚拟机认为内存不足的情况下,也会被垃圾回收。

import java.lang.ref.*;
import java.util.*;
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() {
                System.out.println("Finalizing " + id);
       }
}
public class References {
       private static ReferenceQueue<Grocery> rq = new ReferenceQueue<Grocery>();
       public static void checkQueue() {
                Reference<? extends Grocery> inq = rq.poll();
                 //从队列中取出一个引用
                if(inq != null)
                System.out.println("In queue: "+inq+" : "+inq.get());
       }
       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("Soft " + i), rq);
                System.out.println("Just created: " +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("Weak " + i), rq);
                System.out.println("Just created: " +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("Phantom " + i), rq);
                System.out.println("Just created: " +ref.get());
                pa.add(ref);
       }
       System.gc();
       checkQueue();
}
}

在Java集合中有一种特殊的Map类型:WeakHashMap, 在这种Map中存放了键对象的弱引用,当一个键对象被垃圾回收,那么相应的值对象的引用会从Map中删除。WeakHashMap能够节约存储空间,可用 来缓存那些非必须存在的数据。关于Map接口的一般用法,可参见本书第15章的15.4节(Map)。

以下例程11-16的MapCache类的main()方法创建了一个WeakHashMap对象,它存放了一组Key对象的弱引用,此外main()方法还创建了一个数组对象,它存放了部分Key对象的强引用。

//例程11-16 MapCache.java
import java.util.*;
import java.lang.ref.*;
 
class Key {
String id;
public Key(String id) { this.id = id; }
public String toString() { return id; }
public int hashCode() { 
return id.hashCode();
}
public boolean equals(Object r) {
return (r instanceof Key)
&& id.equals(((Key)r).id);
}
public void finalize() {
System.out.println("Finalizing Key "+ id);
}
}
class Value {
String id;
public Value(String id) { this.id = id; }
public String toString() { return id; }
public void finalize() {
System.out.println("Finalizing Value "+id);
}
}
public class MapCache {
public static void main(String[] args) throws Exception{
int size = 1000;
// 或者从命令行获得size的大小
if(args.length > 0)size = Integer.parseInt(args[0]);
Key[] keys = new Key[size]; //存放键对象的强引用
WeakHashMap<Key,Value> whm = new WeakHashMap<Key,Value>();
for(int i = 0; i < size; i++) {
Key k = new Key(Integer.toString(i));
Value v = new Value(Integer.toString(i));
if(i % 3 == 0) keys[i] = k; //使Key对象持有强引用 
whm.put(k, v); //使Key对象持有弱引用
}
//催促垃圾回收器工作
System.gc();
 
//把CPU让给垃圾回收器线程
Thread.sleep(8000);
}
}
/*以上程序的部分打印结果如下:
Finalizing Key 998
Finalizing Key 997
Finalizing Key 995
Finalizing Key 994
Finalizing Key 992
Finalizing Key 991
Finalizing Key 989
Finalizing Key 988
Finalizing Key 986
Finalizing Key 985
Finalizing Key 983*/

从打印结果可以看出,当执行System.gc()方法后,垃圾回收器只会回收那些仅仅持有弱引用的Key对象。id可以被3整数的Key对象持有强引用,因此不会被回收。

感谢原作者:

原文链接

时间: 2024-10-09 03:10:55

Java 中的引用类型的相关文章

java中的引用类型概念

转自:http://blog.sina.com.cn/s/[email protected]陌上蜗牛 1.什么是引用类型     引用类型(reference type)指向一个对象,不是原始值,指向对象的变量是引用变量. 在java里面除去基本数据类型的其它类型都是引用数据类型,自己定义的class类都是引用类型,可以像基本类型一样使用.     示例如下:     public class MyDate {         private int day = 8;         priva

java中的引用类型和值类型

值类型和引用类型的不同 [定义] 引用类型 表示你操作的数据是同一个,也就是说当你传一个参数给另一个方法时,你在另一个方法中改变这个变量的值,那么调用这个方法时,传入的变量的值也将改变. 值类型 表示复制一个当前变量传给方法,当你在这个方法中改变这个变量的值时,最初声明的变量的值不会变. [值类型] 值类型就是基本数据类型 基本数据类型常被称为四类 八种 整型:byte.short.int.long 浮点型:float.double 字符型:char 逻辑型:boolean [引用类型] 除了四

Java中的引用类型Scanner类和随机类型Random

Scanner类 我们要学的Scanner类是属于引用数据类型,我们先了解下引用数据类型.   引用数据类型的使用 与定义基本数据类型变量不同,引用数据类型的变量定义及赋值有一个相对固定的步骤或格式. 数据类型 变量名 = new 数据类型(); 每种引用数据类型都有其功能,我们可以调用该类型实例的功能. 变量名.方法名(); Scanner类 Scanner类是引用数据类型的一种,我们可以使用该类来完成用户键盘录入,获取到录入的数据. Scanner使用步骤: //导包: import jav

Java中Calender引用类型

某些时候需要使用深拷贝: Calendar startTime = (Calendar) this._paramModel.getStartTime().clone(); 这样对startTime.add(Calendar.MINUTE,30)操作时,this._paramModel.getStartTime()不会随之改变 如果使用Calendar startTime=this._paramModel.getStartTime(),这样在做操作startTime.add(Calendar.MI

Java中的引用类型

强引用(Strong) 就是我们平时使用的方式 A a = new A();强引用的对象是不会被回收的 软引用(Soft) 在jvm要内存溢出(OOM)时,会回收软引用的对象,释放更多内存 弱引用(Weak) 在下次GC时,弱引用的对象是一定会被回收的 虚引用(Phantom) 对对象的存在时间没有任何影响,也无法引用对象实力,唯一的作用就是在该对象被回收时收到一个系统通知 原文地址:https://www.cnblogs.com/jxxblogs/p/12208117.html

Java 中的 ==, equals 与 hashCode 的区别与联系

一.概述 1.概念 == : 该操作符生成的是一个boolean结果,它计算的是操作数的值之间的关系 equals : Object 的 实例方法,比较两个对象的content是否相同 hashCode : Object 的 native方法 , 获取对象的哈希值,用于确定该对象在哈希表中的索引位置,它实际上是一个int型整数 二.关系操作符 == 1.操作数的值 基本数据类型变量 在Java中有八种基本数据类型: 浮点型:float(4 byte), double(8 byte) 整型:byt

Java中的数组和方法

3.1 数组的定义和使用 数组(Array)是用来存储一组相同数据类型数据的集合.数组中的每个数据称为一个元素(element),数组可以分为一维数组,二维数组和多维数组.我们 主要讲解一维数组和二维数组. 3.1.1一维数组的声明数组变量 Java中的数组必须先声明然后再使用,Java中声明数组的方式如下: datatype[] arrayRefVar; 或者 datatype arrayRefVar[]; 例如: double[] array; 或者 double array[]; 说明:我

java中引用的原理【转】

在Java中的引用类型,是指除了基本的变量类型之外的所有类型,所有的类型在内存中都会分配一定的存储空间(形参在使用的时候也会分配存储空间,方法调用完成之后,这块存储空间自动消失), 基本的变量类型只有一块存储空间(分配在stack中), 而引用类型有两块存储空间(一块在stack中,一块在heap中), 方法形参的值传递(引用)是指形参和传进来的参数指向同一个值的内存(heap)中; java是传值还是传引用,这个估计很多人至今都很糊涂,这里有篇文章写的还是可以的,大家可以看看.. 这个写的还是

java中引用的原理

转自:http://blog.163.com/[email protected]/blog/static/112987702200962211145825/ 在Java中的引用类型,是指除了基本的变量类型之外的所有类型,所有的类型在内存中都会分配一定的存储空间(形参在使用的时候也会分配存储空间,方法调用完成之后,这块存储空间自动消失), 基本的变量类型只有一块存储空间(分配在stack中), 而引用类型有两块存储空间(一块在stack中,一块在heap中), 方法形参的值传递(引用)是指形参和传