JAVA四种引用方式

   如何实现一个软引用？

/**
* 实现一个软引用
*/
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());

}

        当执行完gc时，软引用内存还很足时，gc不会清除引用的，所以上面程序执行后，内存空间就入这个图，如果当空间不足时，软引用就会自动加载到内存空间中去。

 如何实现一个弱引用呢？

/**
* 实现一个弱引用
*/
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());
}
}

/**
 * 创建一个引用对象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();
}
}

  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的对象持有强引用被保留了下来

JAVA四种引用方式,古老的榕树,5-wow.com