JVM中强引用,弱引用,软引用和幽灵引用的代码

 上代码: 

public class ReferenceTest {
    public static void main(String[] args) {
        //test1();//软引用
        //test2();//弱引用
        //test3();//幽灵引用_1
        test4();//幽灵引用_2
        
    }
    public static void test1(){
        //在堆中创建一个对象Obj
        //在栈中创建一个p来强引用此对象Obj
        Person p=new Person(1);
        
        //在栈中创建一个softReference来软引用此对象Obj 可以获取对象的属性值
        SoftReference<Person> softReference=new SoftReference<Person>(p);
        System.out.println(p.getId());//输出打印:1
        System.out.println(softReference.get().getId());//输出打印:1
        
        //断开p和Obj的强引用
        p=null;
        //System.out.println(p.getId());    
        //System.gc();
        System.out.println(softReference.get().getId());//输出打印:1 
        //并不报空指针异常  虽然断开了p和Obj的强引用,但是并没有被回收.
        //如果在前面调用gc() 垃圾回收  运行结果也是打印1的..软引用只有系统在发生内存溢出异常之前，会把只被软引用的对象进行回收
    }

    public static void test2(){
        //在堆中创建一个对象Obj
        //在栈中创建一个p来强引用此对象Obj
        Person p=new Person(1);
        
        //在栈中创建一个weakReference来弱引用此对象Obj 可以获取对象的属性值
        WeakReference<Person>  weakReference=new WeakReference<Person>(p);
        System.out.println(weakReference.get().getId());//打印输出:1
        
        //断开p和Obj的强引用
        p=null;
        //System.gc();
        System.out.println(weakReference.get().getId());//打印输出:1 
        //p=null 之后 还是可以正常的打印输出1  说明断开强引用和其他弱引用,软引用压根没有关系.
        //如果在打印之前 调用gc() 方法之后  就会报错..java.lang.NullPointerException
        //垃圾回收不论内存是否不足都会回收只被弱引用关联的对象。
        
    }
    
    public static void test3(){
        //在堆中创建一个对象Obj
        //在栈中创建一个p来强引用此对象Obj
        Person p=new Person(1);
        
        //Phantom 幻影幽灵 的意思
        ReferenceQueue<Person> referenceQueue = new ReferenceQueue<Person>();
        //在栈中创建一个phantomReference来虚引用此对象Obj 不可以获取对象的属性值
        PhantomReference<Person> phantomReference=new PhantomReference<Person>(p,referenceQueue);
        System.out.println(phantomReference.get().getId());//打印报错 java.lang.NullPointerException
        //直接得不到p对象对应的id值....
        //PhantomReference的唯一作用就是 能在这个对象被收集器回收时收到一个系统通知 看test4()方法
    }
    
    public static void test4(){
        
        //在堆中创建一个对象Obj
        //在栈中创建一个p来强引用此对象Obj
        Person p=new Person(1);
        
        //Phantom 幻影幽灵 的意思
        ReferenceQueue<Person> referenceQueue = new ReferenceQueue<Person>();
        //在栈中创建一个phantomReference来虚引用此对象Obj 不可以获取对象的属性值
        PhantomReference<Person> phantomReference=new PhantomReference<Person>(p,referenceQueue);
        
        System.out.println(referenceQueue.poll());//打印输出: null  这个是查询队列中是否有元素.
        
        //断开p和obj的强引用
        p=null;
        System.gc();//p被回收之后 队列referenceQueue中就有值了.
        
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }//过 一秒钟之后再查询队列中是否有元素.
        System.out.println(referenceQueue.poll());//打印输出: java.lang.ref.PhantomReference@77fef1a0
        //PhantomReference的唯一作用就是 能在这个对象被收集器回收时收到一个系统通知 
        //如果这个对象被回收了,会把通知放到队列中.
        
        //如果前面p=null注释掉  再运行打印输出就是  null  因为p没有被回收(强引用中) 就不会把通知放到队列中...队列中为空 null
        //回收的标志就是把通知放到队列中..
    }
}

class Person{
    public Person(Integer id) {
        this.id = id;
    }

    private Integer id;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("finalized!!!!!");
    }
}