本文目录一览：
java三个引用类型
四种引用类型
所以在 JDK.1.2 之后，Java 对引用的概念进行了扩充，将引用分为了：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）、虚引用（Phantom Reference）4 种，这 4 种引用的强度依次减弱。
一，强引用
Java中默认声明的就是强引用，比如：
Object obj = new Object(); //只要obj还指向Object对象，Object对象就不会被回收
obj = null; //手动置null
只要强引用存在，垃圾回收器将永远不会回收被引用的对象，哪怕内存不足时，JVM也会直接抛出OutOfMemoryError，不会去回收。如果想中断强引用与对象之间的联系，可以显示的将强引用赋值为null，这样一来，JVM就可以适时的回收对象了
二，软引用
软引用是用来描述一些非必需但仍有用的对象。在内存足够的时候，软引用对象不会被回收，只有在内存不足时，系统则会回收软引用对象，如果回收了软引用对象之后仍然没有足够的内存，才会抛出内存溢出异常。这种特性常常被用来实现缓存技术，比如网页缓存，图片缓存等。
在 JDK1.2 之后，用java.lang.ref.SoftReference类来表示软引用。
下面以一个例子来进一步说明强引用和软引用的区别：
在运行下面的Java代码之前，需要先配置参数 -Xms2M -Xmx3M，将 JVM 的初始内存设为2M，最大可用内存为 3M。
首先先来测试一下强引用，在限制了 JVM 内存的前提下，下面的代码运行正常
public class TestOOM {
public static void main(String[] args) {
testStrongReference();
}
private static void testStrongReference() {
// 当 new byte为 1M 时，程序运行正常
byte[] buff = new byte[1024 * 1024 * 1];
}
}
但是如果我们将
byte[] buff = new byte[1024 * 1024 * 1];
替换为创建一个大小为 2M 的字节数组
byte[] buff = new byte[1024 * 1024 * 2];
则内存不够使用，程序直接报错，强引用并不会被回收
接着来看一下软引用会有什么不一样，在下面的示例中连续创建了 10 个大小为 1M 的字节数组，并赋值给了软引用，然后循环遍历将这些对象打印出来。
public class TestOOM {
private static ListObject list = new ArrayList();
public static void main(String[] args) {
testSoftReference();
}
private static void testSoftReference() {
for (int i = 0; i 10; i++) {
byte[] buff = new byte[1024 * 1024];
SoftReferencebyte[] sr = new SoftReference(buff);
list.add(sr);
}
System.gc(); //主动通知垃圾回收
for(int i=0; i list.size(); i++){
Object obj = ((SoftReference) list.get(i)).get();
System.out.println(obj);
}
}
}
打印结果：
我们发现无论循环创建多少个软引用对象，打印结果总是只有最后一个对象被保留，其他的obj全都被置空回收了。
这里就说明了在内存不足的情况下，软引用将会被自动回收。
值得注意的一点 , 即使有 byte[] buff 引用指向对象, 且 buff 是一个strong reference, 但是 SoftReference sr 指向的对象仍然被回收了，这是因为Java的编译器发现了在之后的代码中, buff 已经没有被使用了, 所以自动进行了优化。
如果我们将上面示例稍微修改一下：
private static void testSoftReference() {
byte[] buff = null;
for (int i = 0; i 10; i++) {
buff = new byte[1024 * 1024];
SoftReferencebyte[] sr = new SoftReference(buff);
list.add(sr);
}
System.gc(); //主动通知垃圾回收
for(int i=0; i list.size(); i++){
Object obj = ((SoftReference) list.get(i)).get();
System.out.println(obj);
}
System.out.println("buff: " + buff.toString());
}
则 buff 会因为强引用的存在，而无法被垃圾回收，从而抛出OOM的错误。
如果一个对象惟一剩下的引用是软引用，那么该对象是软可及的（softly reachable）。垃圾收集器并不像其收集弱可及的对象一样尽量地收集软可及的对象，相反，它只在真正 “需要” 内存时才收集软可及的对象。
三，弱引用
弱引用的引用强度比软引用要更弱一些，无论内存是否足够，只要 JVM 开始进行垃圾回收，那些被弱引用关联的对象都会被回收。在 JDK1.2 之后，用 java.lang.ref.WeakReference 来表示弱引用。
我们以与软引用同样的方式来测试一下弱引用：
private static void testWeakReference() {
for (int i = 0; i 10; i++) {
byte[] buff = new byte[1024 * 1024];
WeakReferencebyte[] sr = new WeakReference(buff);
list.add(sr);
}
System.gc(); //主动通知垃圾回收
for(int i=0; i list.size(); i++){
Object obj = ((WeakReference) list.get(i)).get();
System.out.println(obj);
}
}
打印结果：
可以发现所有被弱引用关联的对象都被垃圾回收了。
四，虚引用
虚引用是最弱的一种引用关系，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，它随时可能会被回收，在 JDK1.2 之后，用 PhantomReference 类来表示，通过查看这个类的源码，发现它只有一个构造函数和一个 get() 方法，而且它的 get() 方法仅仅是返回一个null，也就是说将永远无法通过虚引用来获取对象，虚引用必须要和 ReferenceQueue 引用队列一起使用。
public class PhantomReferenceT extends ReferenceT {
/**
* Returns this reference object's referent. Because the referent of a
* phantom reference is always inaccessible, this method always returns
* codenull/code.
*
* @return codenull/code
*/
public T get() {
return null;
}
public PhantomReference(T referent, ReferenceQueue? super T q) {
super(referent, q);
}
}
那么传入它的构造方法中的 ReferenceQueue 又是如何使用的呢？
五，引用队列（ReferenceQueue）
引用队列可以与软引用、弱引用以及虚引用一起配合使用，当垃圾回收器准备回收一个对象时，如果发现它还有引用，那么就会在回收对象之前，把这个引用加入到与之关联的引用队列中去。程序可以通过判断引用队列中是否已经加入了引用，来判断被引用的对象是否将要被垃圾回收，这样就可以在对象被回收之前采取一些必要的措施。
楚雄java培训学校告诉你java编程引用类型分析？
我们在使用java编程开发语言开发软件的时候通常都会new对象，然后通过对对象的引用来实现不同的编程需求，而今天电脑培训就一起来了解一下，java编程开发语言中都有哪些常见的引用方法。
1：虚引用
1.1简介：虚引用是所有引用中强度弱的，它完全类似于没有引用，在java.reflact.PhantomReference类中实现。虚引用对象本身没有太大影响，对象甚至感觉不到虚引用的存在。如果一个对象存在虚引用，那么它和没有引用的效果大致相同，虚引用无法引用任何堆中的对象
作用：虚引用主要用于跟踪对象被JVM垃圾回收的状态，可以通过它来手机GC的行为。可以通过检查与虚引用关联的引用队列中是否已经包含指定的虚引用，从而了解虚引用锁引用的对象是否被回收。
注意：虚引用无法单独使用，虚引用必须和引用队列(ReferenceQueue)联合使用.被虚引用所引用对象被垃圾回收后，虚引用将被添加到引用队列中。
2：弱引用
简介：弱引用和虚引用有点类似，不同之处在于虚引用锁引用的对象生存期比虚引用长一点。虚引用在java.reflact.WeakReference类实现。在系统进行垃圾回收的时候，不管系统内存是否足够，总是回收该对象所占用的内存.但是弱引用的强度是要大于虚引用的
3：软引用
简介：软引用比弱引用的强度高一点，它是通过java.reflact.SoftReference来实现。对于软引用来说，当系统内存空间足够时，它不会被系统回收，程序中改对象的引用也是有效的。而当系统的内存空间不够时，系统将会回收它。
作用：软引用是强引用好的替代，它一定程度上可以避免系统内存不足的异常，可以充分使用软引用来解决内存紧张的问题。
4：强引用
简介：强引用很常见，在平时的程序中，我们新new一个对象，比如Objectobject=newObject();那么这个object就是指向object对象的强引用。强引用的特点就是：被引用的java对象绝对不会被垃圾回收机制回收，即使系统的内存非常紧张，即使java以后也用不到，jvm不会回收强引用所引用的java对象。
java中垃圾回收有哪几种机制?
强引用
在一般的Java程序中，见到最多的就是强引用（strong reference）。如Date date = new Date()，date就是一个对象的强引用。对象的强引用可以在程序中到处传递。很多情况下，会同时有多个引用指向同一个对象。强引用的存在限制了对象在内存中的存活时间。假如对象A中包含了一个对象B的强引用，那么一般情况下，对象B的存活时间就不会短于对象A。如果对象A没有显式的把对象B的引用设为null的话，就只有当对象A被垃圾回收之后，对象B才不再有引用指向它，才可能获得被垃圾回收的机会。
除了强引用之外，java.lang.ref包中提供了对一个对象的不同的引用方式。JVM的垃圾回收器对于不同类型的引用有不同的处理方式。
软引用
软引用（soft reference）在强度上弱于强引用，通过类SoftReference来表示。它的作用是告诉垃圾回收器，程序中的哪些对象是不那么重要，当内存不足的时候是可以被暂时回收的。当JVM中的内存不足的时候，垃圾回收器会释放那些只被软引用所指向的对象。如果全部释放完这些对象之后，内存还不足，才会抛出OutOfMemory错误。软引用非常适合于创建缓存。当系统内存不足的时候，缓存中的内容是可以被释放的。比如考虑一个图像编辑器的程序。该程序会把图像文件的全部内容都读取到内存中，以方便进行处理。而用户也可以同时打开多个文件。当同时打开的文件过多的时候，就可能造成内存不足。如果使用软引用来指向图像文件内容的话，垃圾回收器就可以在必要的时候回收掉这些内存。
publicclass ImageData {
private String path;
private SoftReferencebyte[] dataRef;
public ImageData(String path) {
this.path = path;
dataRef = new SoftReferencebyte[](newbyte[0]);
}
privatebyte[] readImage() {
returnnewbyte[1024 * 1024]; //省略了读取文件的操作 }
publicbyte[] getData() {
byte[] dataArray = dataRef.get();
if (dataArray == null || dataArray.length == 0) {
dataArray = readImage();
dataRef = new SoftReferencebyte[](dataArray);
}
return dataArray;
}
}
在运行上面程序的时候，可以使用 -Xmx 参数来限制JVM可用的内存。由于软引用所指向的对象可能被回收掉，在通过get方法来获取软引用所实际指向的对象的时候，总是要检查该对象是否还存活。
弱引用
弱引用（weak reference）在强度上弱于软引用，通过类WeakReference来表示。它的作用是引用一个对象，但是并不阻止该对象被回收。如果使用一个强引用的话，只要该引用存在，那么被引用的对象是不能被回收的。弱引用则没有这个问题。在垃圾回收器运行的时候，如果一个对象的所有引用都是弱引用的话，该对象会被回收。弱引用的作用在于解决强引用所带来的对象之间在存活时间上的耦合关系。弱引用最常见的用处是在集合类中，尤其在哈希表中。哈希表的接口允许使用任何Java对象作为键来使用。当一个键值对被放入到哈希表中之后，哈希表对象本身就有了对这些键和值对象的引用。如果这种引用是强引用的话，那么只要哈希表对象本身还存活，其中所包含的键和值对象是不会被回收的。如果某个存活时间很长的哈希表中包含的键值对很多，最终就有可能消耗掉JVM中全部的内存。
对于这种情况的解决办法就是使用弱引用来引用这些对象，这样哈希表中的键和值对象都能被垃圾回收。Java中提供了WeakHashMap来满足这一常见需求。
幽灵引用
在介绍幽灵引用之前，要先介绍Java提供的对象终止化机制（finalization）。在Object类里面有个finalize方法，其设计的初衷是在一个对象被真正回收之前，可以用来执行一些清理的工作。因为Java并没有提供类似C++的析构函数一样的机制，就通过 finalize方法来实现。但是问题在于垃圾回收器的运行时间是不固定的，所以这些清理工作的实际运行时间也是不能预知的。幽灵引用（phantom reference）可以解决这个问题。在创建幽灵引用PhantomReference的时候必须要指定一个引用队列。当一个对象的finalize方法已经被调用了之后，这个对象的幽灵引用会被加入到队列中。通过检查该队列里面的内容就知道一个对象是不是已经准备要被回收了。
幽灵引用及其队列的使用情况并不多见，主要用来实现比较精细的内存使用控制，这对于移动设备来说是很有意义的。程序可以在确定一个对象要被回收之后，再申请内存创建新的对象。通过这种方式可以使得程序所消耗的内存维持在一个相对较低的数量。