引用 订阅
引用是指在说话或写作中引用现成的话,如诗句、格言、成语等,以表达自己思想感情的修辞方法。引用可分为明引和暗引两种。明引指直接引用原文,并加上引号,或者是只引用原文大意,不加引号,但是都注明原文的出处。暗引指不说明引文出处,而将其编织在自已的话语中,或是引用原句,或是只引大意。运用引用辞格,既可使文章言简意赅,有助于说理抒情;又可增加文采,增强表现力。 [1] 展开全文
引用是指在说话或写作中引用现成的话,如诗句、格言、成语等,以表达自己思想感情的修辞方法。引用可分为明引和暗引两种。明引指直接引用原文,并加上引号,或者是只引用原文大意,不加引号,但是都注明原文的出处。暗引指不说明引文出处,而将其编织在自已的话语中,或是引用原句,或是只引大意。运用引用辞格,既可使文章言简意赅,有助于说理抒情;又可增加文采,增强表现力。 [1]
信息
拼    音
yǐn yòng
作    用
增添感染力,增加文采
中文名
引用
外文名
quote
引用基本解释
引用天下名士。 [2] 
收起全文
精华内容
下载资源
问答
  • 引用
    万次阅读 多人点赞
    2019-01-02 16:56:19

    目录

    一、强引用

    二、软引用

    三、弱引用

    四、虚引用

    五、总结


    在JDK1.2以前的版本中,当一个对象不被任何变量引用,那么程序就无法再使用这个对象。也就是说,只有对象处于可触及状态,程序才能使用它。这就像在商店购买了某样物品后,如果有用就一直保留它,否则就把它扔到垃圾箱,由清洁工人收走。一般说来,如果物品已经被扔到垃圾箱,想再把它捡回来使用就不可能了。

    但有时候情况并不这么简单,可能会遇到可有可无的"鸡肋"物品。这种物品现在已经无用了,保留它会占空间,但是立刻扔掉它也不划算,因为也许将来还会派用场。对于这样的可有可无的物品:如果家里空间足够,就先把它保留在家里,如果家里空间不够,即使把家里所有的垃圾清除,还是无法容纳那些必不可少的生活用品,那么再扔掉这些可有可无的物品。

    在Java中,虽然不需要程序员手动去管理对象的生命周期,但是如果希望某些对象具备一定的生命周期的话(比如内存不足时JVM就会自动回收某些对象从而避免OutOfMemory的错误)就需要用到软引用和弱引用了。

    从Java SE2开始,就提供了四种类型的引用:强引用、软引用、弱引用和虚引用。Java中提供这四种引用类型主要有两个目的:第一是可以让程序员通过代码的方式决定某些对象的生命周期;第二是有利于JVM进行垃圾回收。

    一、强引用

    之前我们使用的大部分引用实际上都是强引用,这是使用最普遍的引用。比如下面这段代码中的object和str都是强引用:

    Object object = new Object();
    String str = "StrongReference";

    如果一个对象具有强引用,那就类似于必不可少的物品,不会被垃圾回收器回收。当内存空间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不回收这种对象。

    public class StrongReference {
    	public static void main(String[] args) {
    		new StrongReference().method1();
    	}
    	public void method1(){
    		Object object=new Object();
    		Object[] objArr=new Object[Integer.MAX_VALUE];
    	}
    }

    运行结果:

    当运行至Object[] objArr = new Object[Integer.MAX_VALUE]时,如果内存不足,JVM会抛出OOM错误也不会回收object指向的对象。不过要注意的是,当method1运行完之后,object和objArr都已经不存在了,所以它们指向的对象都会被JVM回收。

    如果想中断强引用和某个对象之间的关联,可以显示地将引用赋值为null,这样一来的话,JVM在合适的时间就会回收该对象。

    比如ArraryList类的clear方法中就是通过将引用赋值为null来实现清理工作的

    public void clear() {
          modCount++;
    
          // Let gc do its work
          for (int i = 0; i < size; i++)
              elementData[i] = null;
    
          size = 0;
    }

    在ArrayList类中定义了一个私有的变量elementData数组,在调用方法清空数组时可以看到为每个数组内容赋值为null。不同于elementData=null,强引用仍然存在,避免在后续调用 add()等方法添加元素时进行重新的内存分配。使用如clear()方法中释放内存的方法对数组中存放的引用类型特别适用,这样就可以及时释放内存。

     

    二、软引用

    软引用是用来描述一些有用但并不是必需的对象,在Java中用java.lang.ref.SoftReference类来表示。对于软引用关联着的对象,只有在内存不足的时候JVM才会回收该对象。因此,这一点可以很好地用来解决OOM的问题,并且这个特性很适合用来实现缓存:比如网页缓存、图片缓存等。

    软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被JVM回收,这个软引用就会被加入到与之关联的引用队列中。

    import java.lang.ref.SoftReference;
    
    public class SoftRef {  
    
        public static void main(String[] args){  
            System.out.println("start");            
            Obj obj = new Obj();            
            SoftReference<Obj> sr = new SoftReference<Obj>(obj);  
            obj = null;  
            System.out.println(sr.get());  
            System.out.println("end");     
        }       
    }  
    
    class Obj{  
        int[] obj ;  
        public Obj(){  
            obj = new int[1000];  
        }  
    }

    当内存足够大时可以把数组存入软引用,取数据时就可从内存里取数据,提高运行效率

    软引用在实际中有重要的应用,例如浏览器的后退按钮,这个后退时显示的网页内容可以重新进行请求或者从缓存中取出:

    (1)如果一个网页在浏览结束时就进行内容的回收,则按后退查看前面浏览过的页面时,需要重新构建

    (2)如果将浏览过的网页存储到内存中会造成内存的大量浪费,甚至会造成内存溢出这时候就可以使用软引用

     

    三、弱引用

    弱引用也是用来描述非必需对象的,当JVM进行垃圾回收时,无论内存是否充足,都会回收被弱引用关联的对象。在java中,用java.lang.ref.WeakReference类来表示。

    弱引用与软引用的区别在于只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程, 因此不一定会很快发现那些只具有弱引用的对象。所以被软引用关联的对象只有在内存不足时才会被回收,而被弱引用关联的对象在JVM进行垃圾回收时总会被回收。

    import java.lang.ref.WeakReference;
    
    public class WeakRef {
        public static void main(String[] args) {
            WeakReference<String> sr = new WeakReference<String>(new String("hello"));
            System.out.println(sr.get());
            System.gc();                //通知JVM的gc进行垃圾回收
            System.out.println(sr.get());
        }
    }

    运行结果:

    在使用软引用和弱引用的时候,我们可以显示地通过System.gc()来通知JVM进行垃圾回收,但是要注意的是,虽然发出了通知,JVM不一定会立刻执行,也就是说这句是无法确保此时JVM一定会进行垃圾回收的。

     

    弱引用还可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

    Object o = new Object(); //只要o还指向对象就不会被回收
    WeakReference<Object> wr = new WeakReference<Object>(o);

    当要获得weak reference引用的object时, 首先需要判断它是否已经被回收,如果wr.get()方法为空, 那么说明weakCar指向的对象已经被回收了。

    应用场景:如果一个对象是偶尔的使用,并且希望在使用时随时就能获取到,但又不想影响此对象的垃圾收集,那么应该用 Weak Reference 来记住此对象。或者想引用一个对象,但是这个对象有自己的生命周期,你不想介入这个对象的生命周期,这时候就应该用弱引用,这个引用不会在对象的垃圾回收判断中产生任何附加的影响。

     

    四、虚引用

    虚引用和前面的软引用、弱引用不同,它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联,则跟没有引用与之关联一样,在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收的活动。

    虚引用必须和引用队列关联使用,当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。

    import java.lang.ref.PhantomReference;
    import java.lang.ref.ReferenceQueue;
     
     
    public class PhantomRef {
        public static void main(String[] args) {
            ReferenceQueue<String> queue = new ReferenceQueue<String>();
            PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue);
            System.out.println(pr.get());
        }
    }

     

    五、总结

    引用类型被回收时间用途生存时间
    强引用从来不会对象的一般状态JVM停止运行时
    软引用内存不足时对象缓存内存不足时
    弱引用jvm垃圾回收时对象缓存gc运行后
    虚引用未知未知未知

    在实际程序设计中一般很少使用弱引用与虚引用,使用软引用的情况较多,这是因为软引用可以加速JVM对垃圾内存的回收速度,可以维护系统的运行安全,防止内存溢出(OutOfMemory)等问题的产生

     

    利用软引用和弱引用解决OOM问题:假如有一个应用需要读取大量的本地图片,如果每次读取图片都从硬盘读取,则会严重影响性能,但是如果全部加载到内存当中,又有可能造成内存溢出,此时使用软引用可以解决这个问题。

    设计思路是:用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系,在内存不足时,JVM会自动回收这些缓存图片对象所占用的空间,从而有效地避免了OOM的问题。


    参考资料:

    1、https://www.cnblogs.com/dolphin0520/p/3784171.html

    2、https://blog.csdn.net/junjunba2689/article/details/80601729

    更多相关内容
  • JAVA中的引用四种引用类型

    千次阅读 2020-08-30 10:09:38
    关于值类型和引用类型的话题,C++、JAVA、python、go、C#等等高级语言都有相关的概念,只要理解了其底层工作原理,可以说即使是不同的语言,在面试学习工作实践中都可以信手拈来(不要太纠集语言),当然此处我选择了...

    关于值类型和引用类型的话题,C++、JAVA、python、go、C#等等高级语言都有相关的概念,只要理解了其底层工作原理,可以说即使是不同的语言,在面试学习工作实践中都可以信手拈来(不要太纠集语言),当然此处我选择了JAVA,虽然我是搞C++的,具体原因都懂就不废话了。

    一、值类型与引用类型

      1、变量初始化

    int num=10;
    String str="hello"

      

      2、变量赋值
       从上图可以显而易见,num是int基本类型变量,值就直接保存在变量中。str是String引用类型变量,变量中保存的只是实际对象对应的地址信息,而不是实际对象数据。对于而这特性,如下:

    num=20;
    str="java";

      对于基本类型变量num,赋值运算符将会直接修改变量的值,原来的数据将被覆盖掉,被替换为新的值。对于引用类型变量str,赋值运算符只会改变变量中所保存的对象的地址信息,原来对象的地址被覆盖掉,重新写入新对象的地址数据。但原来的对象本身并不会被改变,只是不再被任何引用所指向的对象,即“垃圾对象”,后续会被垃圾回收器回收。

      3、函数传参

     

    // 基本类型参数,原始value不会被更改
        public void func(int value) {
            value = 100;
        }
    
        // 对于没有提供修改自身的成员方法引用类型,原始str不会被更改
        public void func(String str) {
            str = "hello";
        }
    
        StringBuilder sb = new StringBuilder("test");
    
        // 对于提供修改自身的成员方法引用类型,原始的sBuilder会被更改
        public void func(StringBuilder sBuilder) {
            sBuilder.append("aa");
        }
    
        // 原始的sBuilder不会被更改
        public void test(StringBuilder sBuilder) {
            sBuilder = new StringBuilder("111");
        }

     

    说明:对于第三种情况:

    对于第四种情况:

     

     

    二、数据存储方式

      1、局部变量/方法参数

      对于局部变量和方法传递的参数在jvm中的存储方式是相同的,都是存储在栈上开辟的空间中。方法参数空间在进入方法时开辟,方法退出时进行回收。以32为JVM为例,boolean、byte、short、char、int、float以及对应的引用类型都是分配4字节大小的空间,long、double分配8字节大小空间。对于每一个方法来说,最多占用空间大小是固定的,在编译时就已经确定了。当在方法中声明一个int变量i=0或Object变量obj=null时,此时仅仅在栈上分配空间,不影响到堆空间。当new Object()时,将会在堆中开辟一段内存空间并初始化Object对象。

      2、数组类型引用和对象

      当声明数组时,int[]  arr=new int[2];数组也是对象,arr实际上是引用,栈上占用4个字节大小的存储空间,而是会在堆中开辟相应大小空间进行存储,然后arr变量指向它。当声明一个二维数组时,如:int[][]  arr2=new int[2][4],arr2同样在栈中占用4个字节,在堆内存中开辟长度为2,类型为int[]的数组对象,然后arr2指向这个数组。这个数组内部有两个引用类型(大小为4个字节),分别指向两个长度为4类型为int的数组。内存分布如图:

    所以当传递一个数组给一个方法时,数组的元素在方法内部是可以被修改的,但是无法让数组引用指向新的数组。其实,还可以声明:int [][]  arr3=new int[3][],内存分布如下:

      3、String类型数据

      对于String类型,其对象内部需要维护三个成员变量,char[]  chars,int  startIndex,  int  length。chars是存储字符串数据的真正位置,在某些情况下是可以共用的,实际上String类型是不可变类型。例如:String  str=new String("hello"),内存分布如下:

     

    三、JAVA引用类型

      在JAVA中提供了四种引用类型:强引用、软引用、软引用和虚引用。在四种引用类型中,只有强引用FinalReference类型变量是包内可见的,其他三种引用类型均为public,可以在程序中直接使用。

      1、强引用

      强引用是使用最普遍的引用。如果一个对象具有强引用,那么垃圾回收器绝不会回收它。例如:StringBuilder sb = new StringBuilder("test");变量str指向StringBuffer实例所在的堆空间,通过str可以操作该对象。如下:

      强引用特点:

      • 强引用可以直接访问目标对象
      • 只要有引用变量存在,垃圾回收器永远不会回收。JVM即使抛出OOM异常,也不会回收强引用所指向的对象。
      • 强引用可能导致内存泄漏问

       2、软引用

      软引用是除了强引用外,最强的引用类型。可以通过java.lang.ref.SoftReference使用软引用。一个持有软引用的对象,不会被JVM很快回收,JVM会根据当前堆的使用情况来判断何时回收。当堆使用率临近阈值时,才会去回收软引用的对象。因此,软引用可以用于实现对内存敏感的高速缓存。SoftReference的特点是它的一个实例保存对一个Java对象的软引用,该软引用的存在不妨碍垃圾收集线程对该Java对象的回收。也就是说,一旦SoftReference保存了对一个Java对象的软引用后,在垃圾线程对 这个Java对象回收前,SoftReference类所提供的get()方法返回Java对象的强引用。一旦垃圾线程回收该Java对象之后,get()方法将返回null。

    Object obj = new Object();
    SoftReference<Object> sf = new SoftReference<Object>(obj);
    obj = null;
    sf.get();//有时候会返回null
    sf是对obj的一个软引用,通过sf.get()方法可以取到这个对象,当这个对象被标记为需要回收的对象时,则返回null;

      软引用主要用户实现类似缓存的功能,在内存足够的情况下直接通过软引用取值,无需从繁忙的真实来源查询数据,提升速度;当内存不足时,自动删除这部分缓存数据,从真正的来源查询这些数据。使用软引用能防止内存泄露,增强程序的健壮性。软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收器回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。也就是说,ReferenceQueue中保存的对象是Reference对象,而且是已经失去了它所软引用的对象的Reference对象。当调用它的poll()方法的时候,如果这个队列中不是空队列,那么将返回队列前面的那个Reference对象。在任何时候,都可以调用ReferenceQueue的poll()方法来检查是否有它所关心的非强可及对象被回收。如果队列为空,将返回一个null,否则该方法返回队列中前面的一个Reference对象。利用这个方法,可以检查哪个SoftReference所软引用的对象已经被回收,于是可以把这些失去所软引用的对象的SoftReference对象清除掉。

      3、弱引用

      弱引用是一种比软引用较弱的引用类型。在系统GC时,只要发现弱引用,不管系统堆空间是否足够,都会将对象进行回收。在java中,可以用java.lang.ref.WeakReference实例来保存对一个Java对象的弱引用。弱引用与软引用的区别在于:只具有弱引用的对象拥有更短暂的生命周期。不过,由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。弱引用主要用于监控对象是否已经被垃圾回收器标记为即将回收的垃圾,可以通过弱引用的isEnQueued方法返回对象是否被垃圾回收器标记。弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

    Object obj = new Object();
    WeakReference<Object> wf = new WeakReference<Object>(obj);
    obj = null;
    wf.get();//有时候会返回null
    wf.isEnQueued();//返回是否被垃圾回收器标记为即将回收的垃圾

      4、虚引用

      虚引用是所有类型中最弱的一个。一个持有虚引用的对象和没有引用几乎是一样的,随时可能被垃圾回收器回收,当试图通过虚引用的get()方法取得强引用时,总是会失败。并且虚引用必须和引用队列一起使用,它的作用在于检测对象是否已经从内存中删除,跟踪垃圾回收过程。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在垃圾回收后,销毁这个对象,将这个虚引用加入引用队列。程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。

    Object obj = new Object();
    PhantomReference<Object> pf = new PhantomReference<Object>(obj);
    obj=null;
    pf.get();//永远返回null
    pf.isEnQueued();//返回是否从内存中已经删除

     

     

    @Test
        public void test(){
            Map map;
            map = new WeakHashMap<String,Object>();
            for (int i =0;i<10000;i++){
                map.put("key"+i,new byte[i]);
            }
    //        map = new HashMap<String,Object>();
    //        for (int i =0;i<10000;i++){
    //            map.put("key"+i,new byte[i]);
    //        }
        }

     

      使用-Xmx2M限定堆内存,使用WeakHashMap的代码正常运行结束,而使用HashMap的代码段抛出异常:java.lang.OutOfMemoryError: Java heap space。由此可见,WeakHashMap会在系统内存紧张时使用弱引用,自动释放掉持有弱引用的内存数据。但如果WeakHashMap的key都在系统内持有强引用,那么WeakHashMap就退化为普通的HashMap,因为所有的数据项都无法被自动清理。

    展开全文
  • 早在JDK1.2就把对象引用分为四种级别,从而使程序能更灵活控制它的生命周期,级别由高到底依次为:强 >软 > 弱 > 虚引用。而GC垃圾回收器(Garbage Collection)对不同的类型有着不同的处理方法,了解这些...

    前言:满纸荒唐言,一把辛酸泪;都云作者痴,谁解其中味。

    一、概述

    早在JDK1.2就把对象引用分为四种级别,从而使程序能更灵活控制它的生命周期,级别由高到底依次为:强 > 软 > 弱 > 虚引用。而GC垃圾回收器(Garbage Collection)对不同的类型有着不同的处理方法,了解这些处理方式有助于我们写出更高质量的代码。

    在Java中,一切被视为对象,引用则是用来操纵对象的。对象和引用之间的关系可以用遥控器(引用)操控电视机(对象)这个场景来理解。遥控器只要链接电视机那么就能操控电视机,当我们尝试操控一个未指向任何对象的引用去操作对象时,就会出现空指针异常(NullPointerException),就好比遥控器没有链接任何电视机,你却去操控遥控器,那是没法操控的。

    Java有一个重要的有点就是通过垃圾回收机制自动管理内存回收,开发者不需要调用函数来释放内存,内存的分配是由程序分配的,而内存的回收由内存来完成。GC为了释放对象,会监控每一个对象的运行状态,包括申请,引用,被引用和赋值,GC都需要监控。监控对象的状态是为了更加准确地,及时地释放对象,释放对象的原则是该对象不再被引用。但是由于我们因为各种原因导致一些对象使用完后扔被持有引用而没有被回收导致内存泄漏。

    总结了几个引用,下面我们在一一细讲:

    引用类型说明使用场景
    强引用(StrongReference)不会自动回收,最难被GC回收的,宁可抛出异常也不回收强引用指向的对象任何场景
    软引用(SoftReference)内存不足时,GC会回收软引用指向的对象比较少使用,已被LruCache替代
    弱引用(WeakReference)不管内存足不足,只要GC了都能回收弱引用指向的对象常用于避免内存泄漏
    虚引用(PhantomReference)随时都能回收,也称幽灵引用,相当于没有指向任何实例引用跟踪对象是否被回收,很少使用

    二、引用详解

    1.强引用

    强引用(StrongReference)是使用最普遍的引用,如果一个对象属于强引用,不会自动被回收,当内存不足时,jvm宁愿抛出OOM使程序异常也不会回收强引用。当我们使用一个new关键字去创建对象的时候,这个对象的引用就是强引用。

    //str表示强引用,指向new String()这个对象
    String str = new String();

    2.软引用

    软引用(SoftReference)是除了强引用外,最强的引用类型。如果系统内存足够是不会回收软引用指向的对象的,如果系统内存不足那么就会回收。使用软引用,在OutOfMemory异常发生前,软引用指向的对象就可以被释放掉,避免内存达到上限避免crash的发生。

       //创建软引用实例,将bitmap存入到软引用中
       SoftReference<Bitmap> softReference = new SoftReference<>(bitmap);
       Bitmap bitmap = softReference.get()
    
       if ("内存不足"){
            //将软引用中的对象设置为null,否则既持有强引用也持有软引用是无法回收的
            bitmap = null;
            //通知系统回收
            System.gc();
        }

    注意:软引用是在内存不足的时候才会被回收,我们调用System.gc()只是起到通知的作用,JVM什么时候扫描回收对象是它自己的态度决定,就算扫描到软引用也不一定会回收它,只有在内存不足的时候才回收。

    我们尝试使用软引用来保存图片实例;

       ImageView imageView = findViewById(R.id.iv_soft_reference);
       Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher_round);
        //创建软引用实例,将bitmap存入到软引用中
       SoftReference<Bitmap> softReference = new SoftReference<>(bitmap);
            if (softReference.get() != null) {
            imageView.setImageBitmap(softReference.get());
        }

    通过软引用的get()方法获取强Bitmap对象实例的引用,如果对象未被回收那么设置图片到控件上。如果内存紧张,系统就会GC,softReference.get()就不会反悔Bitmap对象,而是反回null,这里也需要把软引用获取的引用做空判断,避免空指针。

    实际情况中,使用软引用虽然可以避免OOM,但是不适用于某些场景,使用的比较少。在Android开发中,一种更好的选择是LruCache,LRU是Least Recently Used的缩写,即“最近最少使用”的意思,它内部会维护一个固定大小的内存,当内存不足时,会把最近最少使用的数据移除掉。

    3.弱引用

    弱引用(WeakReference)是弱于软引用的引用类型,与软引用类似,不同的是弱引用不能阻止垃圾回收,在垃圾回收机制运行时,如果一个对象的引用是弱引用的话,不管内存空间是否足够,对象都会被回收。弱引用常常被用于防止内存泄漏,最常见的是单例和Handler造成的内存泄漏。

    //弱引用实例
    WeakReference<Context> weakReference = new WeakReference<>(context);
    //获取弱引用保存的引用
    Context ctx = weakReference.get();

    注意:如果一个对象比较少使用,并且洗碗在使用是随时就获取到,又不想影响次对象的垃圾回收,你可以用WeakReference来标记此对象。

    我们来看看单例造成的内存泄漏:

    public class InstanceClass {
        private Context mContext;
        private static InstanceClass mInstanceClass;
    
        public InstanceClass(Context context) {
            this.mContext = context;
        }
    
        //传入的Context如果外部类(比如Activity)需要销毁时,InstanceClass仍然持有Context,导致Activity无法销毁回收
        public static InstanceClass getInstance(Context context) {
            if (mInstanceClass == null) {
                mInstanceClass = new InstanceClass(context);
            }
            return mInstanceClass;
        }
    }

    在Activity中使用该实例:

     InstanceClass instanceClass = InstanceClass.getInstance(this);

    单例是开发中比较常用的设计模式,但是使用不当也会造成内存泄漏,如上面例子,InstanceClass通过构造方法持有外部类Activity的引用,因为InstanceClass中的实例是static修饰的,所以InstanceClass的声明周期时和应用声明周期一致,如果当外部类销毁的时候,InstanceClass仍然持有Context,导致Activity无法销毁回收,就会导致内存溢出,我们用图形来说明一下:

    那么我们可以在InstanceClass构造的时候将Activity的引用存入到弱引用中,需要使用的时候再出来;

    public class InstanceClass {
        private Context mContext;
        private static InstanceClass mInstanceClass;
    
        public InstanceClass(Context context) {
            //构造弱引用实例,将context存入弱引用中
            WeakReference<Context> mWeakReference = new WeakReference<>(context);
            //从弱引用中获取,mWeakReference.get()可能为空,需要做空判断
            this.mContext = mWeakReference.get();
        }
    
        //传入的Context如果外部类(比如Activity)需要销毁时,InstanceClass仍然持有Context,导致Activity无法销毁回收
        public static InstanceClass getInstance(Context context) {
            if (mInstanceClass == null) {
                mInstanceClass = new InstanceClass(context);
            }
            return mInstanceClass;
        }
    }

    如果Activity被回收了那么mWeakReference.get()就会返回null,这里需要做空判断。

    4.虚引用

    虚引用(PhantomReference)是最弱的引用,一个持有虚引用的对象和没有引用几乎是一样的,随时都可能被垃圾回收器回收。通过虚引用的get()方法获取到的引用都会失败(为null),虚引用必须和引用队列ReferenceQueue一起使用。

    ReferenceQueue引用队列作用在于跟踪垃圾回收过程。当垃圾回收器回收对象时,如果发现它还有虚引用,就会在回收后销毁这个对象,并且将虚引用指向的对象加入到引用队列。只能通过虚引用是否被加入到ReferenceQueue来判断虚引用是否为GC回收,这也是判断对象是否为回收的唯一途径。

    Java的Object类中有finalize()方法,原理:一旦垃圾回收器准备释放对象占用的内存空间,将首先调用finalize()方法,并且在下一次垃圾回收动作发生时,才会真正回收对象占用的内存,但是问题在于,虚拟机不能保证finalize()何时被调用,因为GC运行时间不是固定的。

    使用虚引用就能解决这个问题,虚引用主要用于跟踪垃圾被回收的活动,主要用来实现比较精细的内存使用控制,这对Android来说很有意义,比如我们可以在确定一个Bitmap被回收后,再去申请另个Bitmap的内存,通过这种方式可以使程序消耗的内存维持在一个相对较低较稳定的水平。

    //引用队列
    ReferenceQueue<Object> queue = new ReferenceQueue<>();
    //虚引用
    PhantomReference<Object> phantomReference = new PhantomReference<Object>(new Object(), queue);
    
    Log.e(TAG, "虚引用:PhantomReference == " + phantomReference.get());
    
    //系统垃圾回收
    System.gc();
    System.runFinalization();
    
    Log.e(TAG, "虚引用:PhantomReference == 是否被回收:" + (queue.poll() == phantomReference) + " | 队列中的PhantomReference == " + queue.poll());

    phantomReference.get()获取的引用一直为null,调用系统回收垃圾,queue.poll()获取保存的引用对象,并且把它在这个队列中移除,打印log如下:

    虚引用无法通过get()方法获取目标的引用,一直都是返回null,可以看源码:

        public T get() {
            return null;
        }
    

    三、回收验证

    上面我们验证了虚引用的垃圾回收,我们这次来验证一下强引用、软引用和弱引用的垃圾回收。这里我们使用System.gc(),如果在Android中使用这个API的话,系统只是通知GC,但是什么时候GC我并不知道,所以我们要把例子放在Java的main方法中执行,因为Java和Android的垃圾收集器是不同的,Android不是使用标准的JVM,而是使用Dalvik VM。

    1.弱引用垃圾回收验证

    在main方法中执行:创建强引用对象,将引用存放到弱引用中,然后手动调用系统gc;

       public static void main(String[] args){
            String str = new String("value");
            WeakReference<String> weakReference = new WeakReference<>(str);
            str = null;
            System.out.println("弱引用:WeakReference == GC回收前:" + weakReference.get());
    
            //系统GC垃圾回收
            System.gc();
    
            System.out.println("弱引用:WeakReference == GC回收后:" + weakReference.get());
        }
    

    这里需要str = null; 如果不设置那么结果返回的都是value,为什么呢?因为如果你不将str = null,那么对象str 既持有强引用,也持有弱引用,当然不会被回收;将打印数据如下:

    在Andorid中(Activity)中执行上面的代码,那么打印的都是value,因为System.gc()只是通知系统去垃圾回收,没有立即去回收,并不知道它什么时候回收。

    点关注,不迷路


    好了各位,以上就是这篇文章的全部内容了,能看到这里的人呀,都是人才。

    我是suming,感谢各位的支持和认可,您的点赞、评论、收藏【一键三连】就是我创作的最大动力,我们下篇文章见!

    如果本篇博客有任何错误,请批评指教,不胜感激 !

    要想成为一个优秀的安卓开发者,这里有必须要掌握的知识架构,一步一步朝着自己的梦想前进!Keep Moving!

    源码地址:https://github.com/FollowExcellence/AndroidOptimizeDemo

    展开全文
  • Java基础篇 - 强引用、弱引用、软引用和虚引用

    万次阅读 多人点赞 2018-09-09 08:58:21
    引用计数:Java堆中每一个对象都有一个引用计数属性,引用每新增1次计数加1,引用每释放1次计数减1。 在JDK 1.2以前的版本中,若一个对象不被任何变量引用,那么程序就无法再使用这个对象。也就是说,只有对象...

    前言

    Java执行GC判断对象是否存活有两种方式其中一种是引用计数

    引用计数:Java堆中每一个对象都有一个引用计数属性,引用每新增1次计数加1,引用每释放1次计数减1。

    JDK 1.2以前的版本中,若一个对象不被任何变量引用,那么程序就无法再使用这个对象。也就是说,只有对象处于(reachable)可达状态,程序才能使用它。

    JDK 1.2版本开始,对象的引用被划分为4种级别,从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为:强引用软引用弱引用虚引用

    正文

    (一) 强引用(StrongReference)

    强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。如下:

        Object strongReference = new Object();

    内存空间不足时,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用对象来解决内存不足的问题。
    如果强引用对象不使用时,需要弱化从而使GC能够回收,如下:

        strongReference = null;

    显式地设置strongReference对象为null,或让其超出对象的生命周期范围,则gc认为该对象不存在引用,这时就可以回收这个对象。具体什么时候收集这要取决于GC算法。

        public void test() {
            Object strongReference = new Object();
            // 省略其他操作
        }

    在一个方法的内部有一个强引用,这个引用保存在Java中,而真正的引用内容(Object)保存在Java中。
    当这个方法运行完成后,就会退出方法栈,则引用对象的引用数0,这个对象会被回收。

    但是如果这个strongReference全局变量时,就需要在不用这个对象时赋值为null,因为强引用不会被垃圾回收。

    ArrayList的Clear方法:

    ArrayList类中定义了一个elementData数组,在调用clear方法清空数组时,每个数组元素被赋值为null
    不同于elementData=null,强引用仍然存在,避免在后续调用add()等方法添加元素时进行内存的重新分配
    使用如clear()方法内存数组中存放的引用类型进行内存释放特别适用,这样就可以及时释放内存。

    (二) 软引用(SoftReference)

    如果一个对象只具有软引用,则内存空间充足时,垃圾回收器不会回收它;如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。

    软引用可用来实现内存敏感的高速缓存。

        // 强引用
        String strongReference = new String("abc");
        // 软引用
        String str = new String("abc");
        SoftReference<String> softReference = new SoftReference<String>(str);

    软引用可以和一个引用队列(ReferenceQueue)联合使用。如果软引用所引用对象被垃圾回收JAVA虚拟机就会把这个软引用加入到与之关联的引用队列中。

        ReferenceQueue<String> referenceQueue = new ReferenceQueue<>();
        String str = new String("abc");
        SoftReference<String> softReference = new SoftReference<>(str, referenceQueue);
    
        str = null;
        // Notify GC
        System.gc();
    
        System.out.println(softReference.get()); // abc
    
        Reference<? extends String> reference = referenceQueue.poll();
        System.out.println(reference); //null

    注意:软引用对象是在jvm内存不够的时候才会被回收,我们调用System.gc()方法只是起通知作用,JVM什么时候扫描回收对象是JVM自己的状态决定的。就算扫描到软引用对象也不一定会回收它,只有内存不够的时候才会回收。

    当内存不足时,JVM首先将软引用中的对象引用置为null,然后通知垃圾回收器进行回收:

        if(JVM内存不足) {
            // 将软引用中的对象引用置为null
            str = null;
            // 通知垃圾回收器进行回收
            System.gc();
        }

    也就是说,垃圾收集线程会在虚拟机抛出OutOfMemoryError之前回收软引用对象,而且虚拟机会尽可能优先回收长时间闲置不用软引用对象。对那些刚构建的或刚使用过的“较新的”软对象会被虚拟机尽可能保留,这就是引入引用队列ReferenceQueue的原因。

    应用场景:

    浏览器的后退按钮。按后退时,这个后退时显示的网页内容是重新进行请求还是从缓存中取出呢?这就要看具体的实现策略了。

    1. 如果一个网页在浏览结束时就进行内容的回收,则按后退查看前面浏览过的页面时,需要重新构建;
    2. 如果将浏览过的网页存储到内存中会造成内存的大量浪费,甚至会造成内存溢出。

    这时候就可以使用软引用,很好的解决了实际的问题:

        // 获取浏览器对象进行浏览
        Browser browser = new Browser();
        // 从后台程序加载浏览页面
        BrowserPage page = browser.getPage();
        // 将浏览完毕的页面置为软引用
        SoftReference softReference = new SoftReference(page);
    
        // 回退或者再次浏览此页面时
        if(softReference.get() != null) {
            // 内存充足,还没有被回收器回收,直接获取缓存
            page = softReference.get();
        } else {
            // 内存不足,软引用的对象已经回收
            page = browser.getPage();
            // 重新构建软引用
            softReference = new SoftReference(page);
        }

    (三) 弱引用(WeakReference)

    弱引用软引用的区别在于:只具有弱引用的对象拥有更短暂生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程,因此不一定很快发现那些只具有弱引用的对象。

        String str = new String("abc");
        WeakReference<String> weakReference = new WeakReference<>(str);
        str = null;

    JVM首先将软引用中的对象引用置为null,然后通知垃圾回收器进行回收:

        str = null;
        System.gc();

    注意:如果一个对象是偶尔(很少)的使用,并且希望在使用时随时就能获取到,但又不想影响此对象的垃圾收集,那么你应该用Weak Reference来记住此对象。

    下面的代码会让一个弱引用再次变为一个强引用

        String str = new String("abc");
        WeakReference<String> weakReference = new WeakReference<>(str);
        // 弱引用转强引用
        String strongReference = weakReference.get();

    同样,弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象垃圾回收Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

    简单测试:

    GCTarget.java

    public class GCTarget {
        // 对象的ID
        public String id;
    
        // 占用内存空间
        byte[] buffer = new byte[1024];
    
        public GCTarget(String id) {
            this.id = id;
        }
    
        protected void finalize() throws Throwable {
            // 执行垃圾回收时打印显示对象ID
            System.out.println("Finalizing GCTarget, id is : " + id);
        }
    }

    GCTargetWeakReference.java

    public class GCTargetWeakReference extends WeakReference<GCTarget> {
        // 弱引用的ID
        public String id;
    
        public GCTargetWeakReference(GCTarget gcTarget,
                  ReferenceQueue<? super GCTarget> queue) {
            super(gcTarget, queue);
            this.id = gcTarget.id;
        }
    
        protected void finalize() {
            System.out.println("Finalizing GCTargetWeakReference " + id);
        }
    }

    WeakReferenceTest.java

    public class WeakReferenceTest {
        // 弱引用队列
        private final static ReferenceQueue<GCTarget> REFERENCE_QUEUE = new ReferenceQueue<>();
    
        public static void main(String[] args) {
            LinkedList<GCTargetWeakReference> gcTargetList = new LinkedList<>();
    
            // 创建弱引用的对象,依次加入链表中
            for (int i = 0; i < 5; i++) {
                GCTarget gcTarget = new GCTarget(String.valueOf(i));
                GCTargetWeakReference weakReference = new GCTargetWeakReference(gcTarget,
                    REFERENCE_QUEUE);
                gcTargetList.add(weakReference);
    
                System.out.println("Just created GCTargetWeakReference obj: " +
                    gcTargetList.getLast());
            }
    
            // 通知GC进行垃圾回收
            System.gc();
    
            try {
                // 休息几分钟,等待上面的垃圾回收线程运行完成
                Thread.sleep(6000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            // 检查关联的引用队列是否为空
            Reference<? extends GCTarget> reference;
            while((reference = REFERENCE_QUEUE.poll()) != null) {
                if(reference instanceof GCTargetWeakReference) {
                    System.out.println("In queue, id is: " +
                        ((GCTargetWeakReference) (reference)).id);
                }
            }
        }
    }

    运行WeakReferenceTest.java,运行结果如下:

    可见WeakReference对象的生命周期基本由垃圾回收器决定,一旦垃圾回收线程发现了弱引用对象,在下一次GC过程中就会对其进行回收。

    (四) 虚引用(PhantomReference)

    虚引用顾名思义,就是形同虚设。与其他几种引用都不同,虚引用不会决定对象的生命周期。如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。

    应用场景:

    虚引用主要用来跟踪对象被垃圾回收器回收的活动。
    虚引用软引用弱引用的一个区别在于:

    虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之关联的引用队列中。

        String str = new String("abc");
        ReferenceQueue queue = new ReferenceQueue();
        // 创建虚引用,要求必须与一个引用队列关联
        PhantomReference pr = new PhantomReference(str, queue);

    程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要进行垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。

    总结

    Java中4种引用的级别和强度由高到低依次为:强引用 -> 软引用 -> 弱引用 -> 虚引用

    垃圾回收器回收时,某些对象会被回收,某些不会被回收。垃圾回收器会从根对象Object标记存活的对象,然后将某些不可达的对象和一些引用的对象进行回收。

    通过表格来说明一下,如下:

    引用类型被垃圾回收时间用途生存时间
    强引用从来不会对象的一般状态JVM停止运行时终止
    软引用当内存不足时对象缓存内存不足时终止
    弱引用正常垃圾回收时对象缓存垃圾回收后终止
    虚引用正常垃圾回收时跟踪对象的垃圾回收垃圾回收后终止

    欢迎关注技术公众号: 零壹技术栈

    image

    本帐号将持续分享后端技术干货,包括虚拟机基础,多线程编程,高性能框架,异步、缓存和消息中间件,分布式和微服务,架构学习和进阶等学习资料和文章。

    展开全文
  • PHP 引用 变量引用 函数引用 对象引用
  • Java对象的四种引用

    千次阅读 2021-09-09 16:00:03
    也就是说,若一个对象不被任何变量引用,那么程序就无法再使用这个对象。垃圾回收器一旦发现这些无用对象,就会对其进行回收。但是,在某些情况下,我们会希望有些对象不需要被立即回收,或者说从全局的角度来说没有...
  • 如果你知道如何交叉引用,可以直接跳转到第2节; 如果你知道如何定义编号格式,但是不会交叉引用,可以直接跳转到 1.2 节。 目录1. 交叉引用1.1 定义有序列表1.2 如何交叉引用1.3 为什么要交叉引用2. 交叉引用多个...
  • JavaScript中的弱引用和强引用

    万次阅读 2021-12-04 14:48:54
    JavaScript中的弱引用和强引用什么是弱引用和强引用举例说明弱引用和强引用在JavaScript中演示弱引用和强引用引用的特性总结 什么是弱引用和强引用 JavaScript 中强引用:对象的引用在 JavaScript 中是强引用,也...
  • python 弱引用

    千次阅读 2019-04-21 17:40:40
    文章目录创建弱引用创建代理对象循环引用缓存对象 (WeakValueDictionary) 垃圾回收 和许多其它的高级语言一样,Python使用了垃圾回收器来自动销毁那些不再使用的对象。每个对象都有一个引用计数,当这个引用计数为...
  • Java从1.2版本开始引入了4种引用,这4种引用的级别由高到低依次为: 强引用 > 软引用 > 弱引用 > 虚引用 ⑴强引用(StrongReference) 强引用是使用最普遍的引用。如果一个对象具...
  • Word交叉引用连续引用多个参考文献

    千次阅读 2022-03-22 16:54:32
    在写论文之时,难免会引用参考文献,有时会连续引用多个参考文献 1.准备好参考文献和引用点 2.交叉引用 比如要连续引用参考文献1-至参考文献4,可先交叉引用参考文献1和参考文献4,交叉引用好的参考文献如下图...
  • java中的方法引用

    万次阅读 多人点赞 2019-08-16 18:03:48
    目录 简介 一,类::静态方法 二,对象::实例方法 ...方法引用可以认为是Lambda表达式的一种特殊形式,Lambda表达式可以让开发者自定义抽象方法的实现代码,方法引用则可以让开发者直接引用已存在的实现方法,...
  • 引用大佬的博客: Java:强引用,软引用,弱引用和虚引用 建议直接看大佬的博客,我这里只做总结。 总结 强引用 相当于 Object obj=new Object()这种引用就是强引用,即使OOM也不会被垃圾回收器进行回收 软引用 如果...
  • 1、引出为什么要有这么多引用?... 2版之后,Java对引用的概念进行了扩充将引用分为强引用(StrongReference)、软引用(Soft Reference) 、弱引用(Weak Reference) 和虚引用(Phantom Reference) 4种,这.
  • 引用 引用的特点 引用与指针的区别 引用的一系列使用
  • 上一篇博客剖析了引用的底层实现原理,文中所述的“引用”默认表示为左值引用。 一、左值与左值引用 什么是左值引用呢? 左值引用,就是绑定到左值的引用,通过&来获得左值引用。 那么,什么是左值呢? 左值,...
  • Excel如何实现跨文件表引用数据这个与使用本簿中的数据没有任何不同(其他工作簿未打开的时据不会更新),只跨工作更没有什么顾忌了。跨工作簿引用数据格式为:'[工作簿名称.xls]工作表名称'!$K$30以上中文都要被实际...
  • 6. LaTeX 参考文献的排版与引用

    千次阅读 多人点赞 2021-11-20 12:09:27
    LaTeX 参考文献的排版与引用 ​ 在论文写作的过程中,为了体现论文的科学性、严谨性和规范性,我们常常需要引用大量的参考文献来引证自己的观点。参考文献(Reference)往往都是放在论文的最后,记录了所引用论文的...
  • Java 是值传递还是引用传递

    万次阅读 多人点赞 2019-03-20 02:40:16
    最近整理面试题,整理到值传递、引用传递,到网上搜了一圈,争议很大。带着一脸蒙圈,线上线下查了好多资料。最终有所收获,所以分享给大家,希望能对你有所帮助。 首先说下我的感受,这个题目出的很好,但是在 ...
  • c++——左值、右值、左值引用、右值引用

    万次阅读 多人点赞 2018-10-18 18:17:39
    你可以把左值引用当成对象的另一个名字,lvalue引用声明由一个可选的说明符列表和一个引用声明符组成。 引用必须初始化,而且不能改变。 一个对象的地址可以 转化成 一种指定类型的指针 或者 转化成 一个 相似...
  • C语言中的引用,以及传递引用,数组传递

    万次阅读 多人点赞 2019-04-08 20:04:48
    详解c++指针的指针和指针的引用 以下参考自:https://www.cnblogs.com/li-peng/p/4116349.html 展示一下使用指针的指针和指针的引用修改传递给方法的指针,以便更好的使用它。(这里说的指针的指针不是一个二维数组...
  • 左值引用和右值引用

    千次阅读 多人点赞 2020-07-25 17:23:08
    右值引用就是必须绑定到右值的引用,他有着与左值引用完全相反的绑定特性,我们通过 && 来获得右值引用。 右值引用的基本语法type &&引用名 = 右值表达式; 右值有一个重要的性质——只能绑定到一个将要销毁的对象...
  • C++ 常量引用用法详解

    千次阅读 多人点赞 2020-11-23 20:37:10
    “常量引用”其实是“对 const 的引用”的简称。 顾名思义,它把它所指向的对象看作是常量(不一定是常量),因此不可以通过该引用来修改它所指向的对象的值。 严格来说,并不存在常量引用,因为引用不是一个对象,...
  • 相对引用、绝对引用、混合引用,经常使用到的是单元格中的相对引用,下面是三个具体的案例,$A11表示列的绝对引用,行的相对引用,A$11表示列的相对引用,行的绝对引用,$A$11表示行与列都是绝对引用,这样在使用...
  • c语言引用详解

    千次阅读 2021-12-20 10:33:33
    引用就是对某一变量起了一个新别名,对引用的操作就是对其变量的操作; int &a=b;//定义引用a,它是变量b的引用名即既是别名 1,引用方法类型标识符(变量的类型)+&+引用名=目标变量名; 2,声明引用时...
  • 分三步, 第一步,插入图片,选中图片,选择插入题注,选择新建标签,图,标签置于项目下方。...第二步,光标切换到要引用的位置处,菜单栏选择引用,交叉引用。选择只引标签和编号关闭。 第三步,更新域。 ...
  • C语言_指针和引用的区别

    千次阅读 2022-05-06 22:11:15
    文章目录指针和引用的区别0、前言1、指针、指针变量和引用2、指针变量和引用变量的定义3、引用的用途4、引用和指针的区别5、引用的底层原理6、代码示例6.1、示例程序16.2、示例程序2 指针和引用的区别 0、前言 最近...
  • Markdown中的引用与交叉引用

    千次阅读 2021-01-20 19:52:59
    全文目录大纲Markdown中的引用与交叉引用一、Markdown中的引用二、Markdown中的交叉引用正文中引用图片正文中引用参考文献 一、Markdown中的引用 Markdown中的引用使用方法为在要引用的文字前输>,如: > 你好...
  • 详解C++中右值引用

    千次阅读 多人点赞 2020-01-14 11:35:52
    98中的引用 概念 特性 引用的使用场景 三种传参方式效率的比较 探索:引用的底层实现方式----->指针 T&------>T* const const T&---->const T*const 引用和指针的区别 引用的总结 11中的右值...
  • Java四种引用

    千次阅读 2021-08-15 21:04:59
    在JDK 1.2版之后,Java对引用的概念进行了扩充,将引用分为强引用(Strongly Re-ference)、软引用(Soft Reference)、弱引用(Weak Reference)和虚引用(Phantom Reference)4种,这4种引用强 度依次逐渐减弱。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,409,716
精华内容 1,763,886
关键字:

引用

友情链接: image2LCD.zip