现在的位置: 首页 > 综合 > 正文

JAVA四种引用方式

2018年07月12日 ⁄ 综合 ⁄ 共 7456字 ⁄ 字号 小 中 大 ⁄ 评论关闭

转自：http://www.2cto.com/kf/201403/285767.html

前言
上周周会老大说到这个，顿时觉得记得不扎实了，哈哈～ 虽然这个在项目应用中是偏底层，基本上是不会开发的，线上也不会允许用到这些，但作为java基础知识，还是来回顾下java基础中的四种引用方式强引用、软引用、弱引用、虚引用。
1.引用的基本概念
1.1、强引用
当我们使用new 这个关键字创建对象时被创建的对象就是强引用，如Object object = new Object() 这个Object()就是一个强引用了，如果一个对象具有强引用。垃圾回收器就不会去回收有强引用的对象。如当jvm内存不足时，具备强引用的对象，虚拟机宁可会报内存空间不足的异常来终止程序，也不会靠垃圾回收器去回收该对象来解决内存。
1.2、软引用
如果一个对象具备软引用，如果内存空间足够，那么垃圾回收器就不会回收它，如果内存空间不足了，就会回收该对象。当然没有被回收之前，该对象依然可以被程序调用。
1.3、弱引用
如果一个对象只具有弱引用，只要垃圾回收器在自己的内存空间中线程检测到了，就会立即被回收，对应内存也会被释放掉。相比软引用弱引用的生命周期要比软引用短很多。不过，如果垃圾回收器是一个优先级很低的线程，也不一定会很快就会释放掉软引用的内存。
1.4、虚引用
如果一个对象只具有虚引用，那么它就和没有任何引用一样，随时会被jvm当作垃圾进行回收。 
2、jdk引用级别
jdk1.2以前是没有这些概念，在jdk1.2以后的版本中才开始引入了引用的四种级别依次是，强引用、软引用、弱引用和虚引用。
jdk中java.lang.ref.Reference类就是java引用抽象基类，reference定义了引用对象的操作。当然该类是与垃圾回收器配合使用的。

3、引用和队列的使用
强引用一般是不会和队列一起使用的，这个过滤掉。
软引用可以和一个引用队列来联合使用，一般软引用可以用来实现内存敏感的高速缓存，如果软引用的所引用的对象被垃圾回收，java虚拟机就会把引用入到与之关联的引用队列中去。
弱引用和队列使用在一起，如果弱引用被所引用的对象回收了，java虚拟机就会把这个弱引用加入到关联的队列中去；
虚引用，在java虚拟机回收虚引用时，会把这个虚引用放到与之关联的引用队列中去。程序可以通过判断引用队列中是否已经引用了虚引用，来了解引用对象是否要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么可以在所引用的对象内存前，采取一些逻辑处理。

4、jdk中的引用实现类
代表软引用的类：java.lang.ref.SoftReference
代表弱引用的类：java.lang.ref.WeakReference
代表虚引用的类：java.lang.ref.PhantomReference
他们同时继承了：java.lang.ref.Reference
引用队列：java.lang.ref.ReferenceQueue,这个引用队列是可以三种引用类型联合使用的，以便跟踪java虚拟机回收所引用对象的活动。
5、引用例子

如何实现一个软引用？

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
*
实现一个软引用
*/
public

static 
void
testSoftReference(){
//创建一个强引用Test
String
str = new

String("Test");
//创建一个引用队列
ReferenceQueue<string>
rq = new

ReferenceQueue<string>();
//实现一个软引用，将强引用类型str和是实例化的rq放到软引用实现里面
SoftReference<string>
srf = new

SoftReference<string>(str,rq);
//通过软引用get方法获取强引用中创建的内存空间Test值
System.out.println(srf.get());
//程序执行下gc现在jvm的内存空间还有很多所以gc不会回收str的对象
System.gc();
//所以这里执行get还是会打印Test的
System.out.println(srf.get());
 
}</string></string></string></string>

执行完这个软引用，那么jvm堆栈区会是什么样呢？

<img src="http://www.2cto.com/uploadfile/Collfiles/20140316/20140316100002206.jpg" alt="" http:="" www.2cto.com="" kf="" ware="" vc="" "="" target="_blank" class="keylink" style="border-width: 0px; padding: 0px; margin: 0px; list-style: none; width: 533px;
height: 377px;">vcTatOa/1bzk1tDIpaGjPGJyPgo8aW1nIHNyYz0="http://www.2cto.com/uploadfile/Collfiles/20140316/20140316100002208.jpg" alt="\">
如何实现一个弱引用呢？

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
*
实现一个弱引用
*/
public

static 
void
testWeakReference(){
String
str = new

String("Test");
ReferenceQueue<string>
rq = new

ReferenceQueue<string>();
//实现一个弱引用，将强引用类型str和是实例化的rq放到弱引用实现里面
WeakReference<string>
wrf = new

WeakReference<string>(str,rq);
//给str给值为null。
然后再通过WeakReference弱引用的get()方法获得Test对象的引用
str
= null;
//程序多执行gc，提高gc执行线程频率来回收对象。
System.gc();
//假如它还没有被垃圾回收，那么接下来在第执行wrf.get()方法会返回Test对象的引用，并且使得这个对象被str1强引用。
//再接下来在行执行rq.poll()方法会返回null，因为此时引用队列中没有任何引用。
String
str1 = wrf.get();
System.out.println(str1);
//ReferenceQueue的poll()方法用于返回队列中的引用，如果没有则返回null。
Reference<string>
ref= (Reference<string>) rq.poll();
System.out.println("弱引用已消失"+ref);
if(ref!=null){
System.out.println(ref.get());
}
}</string></string></string></string></string></string>


6、综合实例

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
/**
 *
创建一个引用对象ref
 *
@author TianYou
 */
public

class
RefObject {
private

static
final
int
size = 80000;
//创建一个Object数组，这样会占用很大的内存空间。预计大概会有640k左右的内存被占用
private

Object[] object = new

Object[size];
private

String refId;
public

RefObject(String id){
this.refId
= id ;
}
public

String RefIdToString(){
return

refId;
}
public

void
findName(){
System.out.println("findName="+refId);
}
 
}
 
测试类
package

reference;
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.HashSet;
import

java.util.Set;
/**
 *
测试引用
 *
@author TianYou
 */
public

class
TestReference {
//创建一个引用队列
private

static
ReferenceQueue<refobject> rq = new

ReferenceQueue<refobject>();
private

static
int
size = 10;
/**
*
验证队列
*/
public

static
void
checkQueue(){
Reference<!--?
extends

RefObject--> ref = rq.poll();
if(null

!= ref)
System.out.println("In
queue: "+ref+"
: "+ref.get());
}
 
/**
*
创建10个RefObject对象\以及10个软引用
*/
public

static
void
testSoftReference(){
System.out.println("--------执行软引用开始-------");
Set<softreference<refobject>>
sa = new

HashSet<softreference<refobject>>();
for(int

i = 0;
i < size; i++) {
SoftReference<refobject>
ref= new

SoftReference<refobject>(new

RefObject("SoftReference
"
+ i), rq);
System.out.println("Just
created: "
+ref.get());
sa.add(ref);
}
System.gc();
checkQueue();
System.out.println("--------执行软引用结束-------");
}
 
/**
*
创建10个Grocery对象以及10个弱引用
*/
public

static
void
testWeakReference(){
System.out.println("--------执行弱引用开始-------");
Set<weakreference<refobject>>
wa = new

HashSet<weakreference<refobject>>();
for(int

i = 0;
i < size; i++) {
WeakReference<refobject>
ref=new

WeakReference<refobject>(new

RefObject("WeakReference
"
+ i), rq);
System.out.println("Just
created: "
+ref.get());
wa.add(ref);
}
System.gc();
checkQueue();
System.out.println("--------执行软弱用结束-------");
}
 
/**
*
创建10个Grocery对象以及10个虚引用
*/
public

static
void
testPhantomReference(){
System.out.println("--------执行虚引用开始-------");
Set<phantomreference<refobject>>
pa = new

HashSet<phantomreference<refobject>>();
for(int

i = 0;
i < size; i++) {
PhantomReference<refobject>ref
=
new

PhantomReference<refobject>(new

RefObject("PhantomReference
"
+ i), rq);
System.out.println("Just
created: "
+ref.get());
pa.add(ref);
}
System.gc();
checkQueue();
System.out.println("--------执行虚弱用结束-------");
}
public

static
void
main(String args[]){
testSoftReference();
testWeakReference();
testPhantomReference();
}
}</refobject></refobject></phantomreference<refobject></phantomreference<refobject></refobject></refobject></weakreference<refobject></weakreference<refobject></refobject></refobject></softreference<refobject></softreference<refobject></refobject></refobject>

在综合实例这里可以看到，三个引用依次都创建了10次，都包含了一个refobject对象，从打印结果可以明确看出，虚引用基本是形同虚设，它引用的对象随时会被垃圾回收器回收，具有弱引用的对象拥有的稍微长一点的生命周期，但垃圾回收器执行回操作时，依然有可能回被垃圾回收器回收，生命周期长的还是软引用。但在虚拟机内存不足的情况下依然会被回收，所以可出这些引用的方式真的不适合在线上使用，否则在极度容易出现鼓掌而在排查时很难检测出结果。
7、弱引用的WeakHashMap
弱引用的jar路径java.util.WeakHashMap。它是弱引用为键实现的哈希表的map。在weakHashMap表某个键不正常时，将会自动移出那个不正常的键。如果对持有强引用的key，它就会一直存在。同时它也支持null key和null value。更精确地说，对于一个给定的key，其映射的存在并不阻止垃圾回收器对该key的回收，这就使该key可以被终止的，key被终止，然后垃圾回收器回收。回收某个key时，其条目从映射中也会被有效地移除，因此，该类的行为与其他的
Map 实现有所不同
接下来也看看实例。
创建一个key对象

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
  public

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); 
    }
}
创建一个value对象
public

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); 
    } 
}
 
测试对象
     import

java.util.WeakHashMap;
public

class
MapCache {
public

static
void
main(String[] args) throws

Exception { 
        int

size = 10000;
        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 % 5

== 0) 
                keys[i]
= k; //
使Key对象持有强引用  
            whm.put(k,
v); //
使Key对象持有弱引用 
        } 
        //
催促垃圾回收器工作 
        System.gc();
        //
把CPU让给垃圾回收器线程 
        Thread.sleep(8000); 
    } 
}
 
运行结果看出来
整出5的对象持有强引用被保留了下来</key,value></key,value>

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞