精华内容
下载资源
问答
  • 背景:收到公众投稿,《从面试题中看Java的Reference(引用)》,分析的很不错,总感觉少了实际的例子和应用场景。于是结合自己工作中场景,小总结一下。看下Agenda如下: 1、强引用 2、软引用 3、弱引用 4、什么时候...

    转载请把头部出处链接和尾部二维码一起转载,本文出自逆流的鱼yuiop:http://blog.csdn.net/hejjunlin/article/details/52637333

    背景:收到公众投稿,《从面试题中看Java的Reference(引用)》,分析的很不错,总感觉少了实际的例子和应用场景。于是结合自己工作中场景,小总结一下。看下Agenda如下:

    • 强引用
    • 软引用
    • 弱引用
    • 什么时候使用软引用,什么时候使用弱引用?
    • 虚引用

    一、强引用

    Java中的引用,类似于C++的指针。通过引用,可以对堆中的对象进行操作。在某个函数中,当创建了一个对象,该对象被分配在堆中,通过这个对象的引用才能对这个对象进行操作。

    这里写图片描述

    假设以上代码是在方法内运行的,那么局部变量str将被分配在栈空间上,而对象StringBuffer实例,被分配在堆空间中。局部变量str指向StringBuffer实例所在的堆空间,通过str可以操作该实例,那么str就是StringBuffer的引用。

    这里写图片描述

    此时,运行一个赋值语句:

    这里写图片描述

    那么,str所指向的对象也将被str1所指向,同时在局部栈空间上会分配空间存放str1变量。此时,该StringBuffer实例就有两个引用。对引用的”==”操作用于表示两个操作数所指向的堆空间地址是否相同,不表示两个操作数所指向的对象是否相等。

    这里写图片描述

    强引用特点:

    • 强引用可以直接访问目标对象。
    • 强引用所指向的对象在任何时候都不会被系统回收。JVM宁愿抛出OOM异常,也不会回收强引用所指向的对象。
    • 强引用可能导致内存泄露。

    二、软引用

    软引用是除了强引用外,最强的引用类型。可以通过java.lang.ref.SoftReference使用软引用。一个持有软引用的对象,不会被JVM很快回收,JVM会根据当前堆的使用情况来判断何时回收。当堆的使用率临近阈值时,才会回收软引用的对象。
    看下我工作中使用到软引用的场景,加载一个1080x1920分辨率的图,约900多K, 对于我们来说,这个图已是非常大了。

    这里写图片描述

    • 首先通过BitmapFactory.decodeStream构造一个大图bitmap
    • 然后把这个bitmap转成Drawble类型,构成强引用。
    • 接着使用SoftReference构造这个drawable对象的软引用drawables.
    • 最后通过软引用的get()方法,取得drawable对象实例的强引用,发现对象被未回收。在GC在内存充足的情况下,不会回收软引用对象。

    • 在实际中,一起请求很多相关图片,从网络,这时就会请求非常多的内存空间,导致内存吃紧,系统开始会GC。这次GC后,drawables.get()不再返回Drawable对象,而是返回null,这时屏幕上背景图不显示,说明在系统内存紧张的情况下,软引用被回收。

    • 使用软引用以后,在OutOfMemory异常发生之前,这些缓存的图片资源的内存空间可以被释放掉的,从而避免内存达到上限,避免Crash发生。

    • 需要注意的是,在垃圾回收器对这个Java对象回收前,SoftReference类所提供的get方法会返回Java对象的强引用,一旦垃圾线程回收该Java对象之后,get方法将返回null。所以在获取软引用对象的代码中,一定要判断是否为null,以免出现NullPointerException异常导致应用崩溃。

    到底什么时候使用软引用,什么时候使用弱引用呢?

    个人认为,如果只是想避免OutOfMemory异常的发生,则可以使用软引用。如果对于应用的性能更在意,想尽快回收一些占用内存比较大的对象,则可以使用弱引用。

    还有就是可以根据对象是否经常使用来判断。如果该对象可能会经常使用的,就尽量用软引用。如果该对象不被使用的可能性更大些,就可以用弱引用。

    另外,和弱引用功能类似的是WeakHashMap。WeakHashMap对于一个给定的key,其映射的存在并不阻止垃圾回收器对该键的回收,回收以后,其条目从映射中有效地移除。WeakHashMap使用ReferenceQueue实现的这种机制。

    三、 弱引用

    弱引用是一种比软引用较弱的引用类型。在系统GC时,只要发现弱引用,不管系统堆空间是否足够,都会将对象进行回收。但是,由于垃圾回收器的线程通常优先级很低,因此,并一不定能很快的发现持有弱引用的对象。这种情况下,弱引用对象可以存在较长的一段时间。一旦一个弱引用对象被垃圾回收器回收,便会加入到一个注册引用队列中。
    看一个工作中实例:播放器的播放Panel,是一个View,就是在视频播放时,可以show、hide, 也可以拖拽进度条之类,还有上面的音量,亮度调节等。这样一个view,我们用弱引用,因为在视频播放过程中,不论硬解还是软解,都将占用大量内存。保证视频的渲染效果。
    在VideoControllerView.java 有如下一段代码:

    这里写图片描述

    在GC之前,弱引用对象并未被垃圾回收器发现,因此通过mView.get()方法可以取得对应的强引用。但是只要进行垃圾回收,弱引用对象一旦被发现,便会立即被回收,并加入注册引用队列中。此时,再次通过mView.get()方法取得强引用就会失败。

    注意:软引用,弱引用都非常适合来保存那些可有可无的缓存数据。如果这样做,当系统内存不足时,这些缓存数据会被回收,不会导致内存溢出。而当内存资源充足时,这些缓存数据又可以存在相当长的时间。

    四、 虚引用

    • 虚引用是所有引用类型中最弱的一个。一个持有虚引用的对象,和没有引用几乎是一样的,随时都可能被垃圾回收器回收。当试图通过虚引用的get()方法取得强引用时,总是会失败。并且,虚引用必须和引用队列一起使用,它的作用在于跟踪垃圾回收过程。
    • 当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在垃圾回收后,销毁这个对象,奖这个虚引用加入引用队列。
    • 实际中几乎没用,暂不介绍。

    最后一张图总结下:

    这里写图片描述

    第一时间获得博客更新提醒,以及更多android干货,源码分析,欢迎关注我的微信公众号,扫一扫下方二维码或者长按识别二维码,即可关注。

    这里写图片描述

    如果你觉得好,随手点赞,也是对笔者的肯定,也可以分享此公众号给你更多的人,原创不易

    展开全文
  • java - 四种强弱软虚引用使用到的场景

    1、强引用(StrongReference)

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

      Object o=new Object();   //  强引用
    

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

     o=null;     // 帮助垃圾收集器回收此对象
    

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

    举例:

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

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

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

    强引用在实际中有非常重要的用处,举个ArrayList的实现源代码:

     private transient Object[] elementData;
    
     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()方法中释放内存的方法对数组中存放的引用类型特别适用,这样就可以及时释放内存。

    2、软引用(SoftReference)

    如果一个对象只具有软引用,则内存空间足够,垃圾回收器就不会回收它;如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。

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

    当内存不足时,等价于:

    If(JVM.内存不足()) {
    
      str = null;  // 转换为软引用
    
      System.gc(); // 垃圾回收器进行回收
    }
    

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

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

    (2)如果将浏览过的网页存储到内存中会造成内存的大量浪费,甚至会造成内存溢出

    这时候就可以使用软引用

    Browser prev = new Browser();               // 获取页面进行浏览
    
    SoftReference sr = new SoftReference(prev); // 浏览完毕后置为软引用    
    
    if(sr.get()!=null){ 
    
    rev = (Browser) sr.get();           // 还没有被回收器回收,直接获取
    
    }else{
    
    prev = new Browser();               // 由于内存吃紧,所以对软引用的对象回收了
    
    sr = new SoftReference(prev);       // 重新构建
    
    }
    

    这样就很好的解决了实际的问题。

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

    3、弱引用(WeakReference)

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

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

    当垃圾回收器进行扫描回收时等价于:

    str = null;
    
    System.gc();
    

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

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

    String  abc = abcWeakRef.get();
    

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

    当你想引用一个对象,但是这个对象有自己的生命周期,你不想介入这个对象的生命周期,这时候你就是用弱引用。

    这个引用不会在对象的垃圾回收判断中产生任何附加的影响。

    public class ReferenceTest {
    
    
    
    private static ReferenceQueue<VeryBig> rq = new ReferenceQueue<VeryBig>();
    
    
    
    public static void checkQueue() {
    
        Reference<? extends VeryBig> ref = null;
    
        while ((ref = rq.poll()) != null) {
    
            if (ref != null) {
    
                System.out.println("In queue: "   + ((VeryBigWeakReference) (ref)).id);
    
            }
    
        }
    
    }
    
    
    
    public static void main(String args[]) {
    
        int size = 3;
    
        LinkedList<WeakReference<VeryBig>> weakList = new LinkedList<WeakReference<VeryBig>>();
    
        for (int i = 0; i < size; i++) {
    
            weakList.add(new VeryBigWeakReference(new VeryBig("Weak " + i), rq));
    
            System.out.println("Just created weak: " + weakList.getLast());
    
    
    
        }
    
    
    
        System.gc(); 
    
        try { // 下面休息几分钟,让上面的垃圾回收线程运行完成
    
            Thread.currentThread().sleep(6000);
    
        } catch (InterruptedException e) {
    
            e.printStackTrace();
    
        }
    
        checkQueue();
    
    } 
     }
    
    
    
    class VeryBig {
    
    public String id;
    
    // 占用空间,让线程进行回收
    
    byte[] b = new byte[2 * 1024];
    
    
    
    public VeryBig(String id) {
    
        this.id = id;
    
    }
    
    
    
    protected void finalize() {
    
        System.out.println("Finalizing VeryBig " + id);
    
    }
    }
    
    
    
    class VeryBigWeakReference extends WeakReference<VeryBig> {
    
    public String id;
    
    
    
    public VeryBigWeakReference(VeryBig big, ReferenceQueue<VeryBig> rq) {
    
        super(big, rq);
    
        this.id = big.id;
    
    }
    
    
    
    protected void finalize() {
    
        System.out.println("Finalizing VeryBigWeakReference " + id);
    
    }
    

    }

    最后的输出结果为:

    Just created weak: com.javabase.reference.VeryBigWeakReference@1641c0

    Just created weak: com.javabase.reference.VeryBigWeakReference@136ab79

    Just created weak: com.javabase.reference.VeryBigWeakReference@33c1aa

    Finalizing VeryBig Weak 2

    Finalizing VeryBig Weak 1

    Finalizing VeryBig Weak 0

    In queue: Weak 1

    In queue: Weak 2

    In queue: Weak 0

    4、虚引用(PhantomReference)

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

    虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于:虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之关联的引用队列中。

    5、总结

    Java4种引用的级别由高到低依次为:

    强引用 > 软引用 > 弱引用 > 虚引用

    通过图来看一下他们之间在垃圾回收时的区别:

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

    展开全文
  • mac Endnote x9插入文献引用使用指南

    万次阅读 热门讨论 2019-11-02 15:33:56
    一、如何获得文献引用模板 (1)万方 二、修改引用文献生成的模板 (1)改上标文献引用形式 (2)修改输出引用格式 三、word中如何插入引用 一、如何获得文献引用模板 (1)万方 (1)点击导出 (2)选择...

    目录

    一、如何获得文献引用模板

    (1)万方

    二、修改引用文献生成的模板

    (1)改上标文献引用形式

    (2)修改输出引用格式

    三、word中如何插入引用

     

    一、如何获得文献引用模板

    (1)万方

    (1)点击导出

    (2)选择endnote

    (3)桌面新建一个txt,复制保存即可

    (4)选择File-import

    options更改为endnote

    而后选择刚刚保存的文件,imort即可插入,获得了我们的模板,有部分有问题处可以自行修改

     

    二、修改引用文献生成的模板

    选择Numbered,这里因为我已经修改完,我把我修改的Numbered命名为Numbered_DIY了

    再一次选择edit

    (1)改上标文献引用形式

    将[Bibliography Number]复制到word中并修改为上标格式,然后再复制回endnote里面style manager里你想改的那个style,找到citations,下面有个templates的第一行粘贴进去,记得粘贴的时候不要直接粘贴,要用edit里面的paste with text style。

    (2)修改输出引用格式

    如图,我已经修改了Joural的输出格式

    接下来修改作者输出个数和形式:保证2个作者时用逗号分隔,3个以上作者用et al

     

    最后,在word中选择我们自定义的style即可

    此时插入的期刊就会像我们自定义那样形式输出:

    此时为原始Numbered模板:

    改为我们的Numbered_DIY后:

     

    (3)为前面的文献编号加上中括号[]

    http://www.cappchem.com/Html/812.html

    Bibliography Number前后加入中括号应用即可

     

    三、word中如何插入引用

    (1)在endnote中选中要插入的文献

    (2)打开word,将光标移到要插入处,然后点击Insert Selected Citations既可插入

    展开全文
  • 从 JDK1.2 版本开始,Java 把对象的引用分为...强引用就是我们经常使用引用,其写法如下: Object&nbsp;o&nbsp;=&nbsp;new&nbsp;Object(); 只要还有强引用指向一个对象,垃圾收集器就不会回收这个...

    从 JDK1.2 版本开始,把对象的引用分为四种级别,从而使程序能更加灵活的控制对象的生命周期。这四种级别由高到低依次为:强引用、软引用、弱引用和虚引用。

    1、强引用(Strong Reference)

    强引用就是我们经常使用的引用,其写法如下:

    Object o = new Object();
    

    特点

    • 只要还有强引用指向一个对象,垃圾收集器就不会回收这个对象。
    • 显式地设置 o 为 null,或者超出对象的生命周期,此时就可以回收这个对象。具体回收时机还是要看垃圾收集策略。
    • 在不用对象的时将引用赋值为 null,能够帮助垃圾回收器回收对象。比如 ArrayList 的 clear() 方法实现:
     public void clear() {
         modCount++;
    
         // clear to let GC do its work
         for (int i = 0; i < size; i++)
             elementData[i] = null;
         size = 0;
     }
    

    2、软引用(Soft Reference)

    如果一个对象只具有软引用,在内存足够时,垃圾回收器不会回收它;如果内存不足,就会回收这个对象的内存。

    使用场景:

    • 图片缓存。图片缓存框架中,“内存缓存”中的图片是以这种引用保存,使得 JVM 在发生 OOM 之前,可以回收这部分缓存。
    • 网页缓存。
    Browser prev = new Browser();               // 获取页面进行浏览
    SoftReference sr = new SoftReference(prev); // 浏览完毕后置为软引用		
    if(sr.get()!=null) { 
    	rev = (Browser) sr.get();           // 还没有被回收器回收,直接获取
    } else {
    	prev = new Browser();               // 由于内存吃紧,所以对软引用的对象回收了
    	sr = new SoftReference(prev);       // 重新构建
    }
    

    3、弱引用(Weak Reference)

    简单来说,就是将对象留在内存的能力不是那么强的引用。当垃圾回收器扫描到只具有弱引用的对象,不管当前内存空间是否足够,都会回收内存。

    使用场景

    在下面的代码中,如果类 B 不是虚引用类 A 的话,执行 main 方法会出现内存泄漏的问题, 因为类 B 依然依赖于 A。

    public class Main {
        public static void main(String[] args) {
    
            A a = new A();
            B b = new B(a);
            a = null;
            System.gc();
            System.out.println(b.getA());  // null
    
        }
    
    }
    
    class A {}
    
    class B {
    
        WeakReference<A> weakReference;
    
        public B(A a) {
            weakReference = new WeakReference<>(a);
        }
    
        public A getA() {
            return weakReference.get();
        }
    }
    

    在静态内部类中,经常会使用虚引用。例如:一个类发送网络请求,承担 callback 的静态内部类,则常以虚引用的方式来保存外部类的引用,当外部类需要被 JVM 回收时,不会因为网络请求没有及时回应,引起内存泄漏。

    4、虚引用(Phantom Reference)

    虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。

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

    Object obj = new Object();
    ReferenceQueue refQueue = new ReferenceQueue();
    PhantomReference<Object> phantomReference = new PhantomReference<Object>(obj,refQueue);
    

    使用场景

    可以用来跟踪对象呗垃圾回收的活动。一般可以通过虚引用达到回收一些非java内的一些资源比如堆外内存的行为。例如:在 DirectByteBuffer 中,会创建一个 PhantomReference 的子类Cleaner的虚引用实例用来引用该 DirectByteBuffer 实例,Cleaner 创建时会添加一个 Runnable 实例,当被引用的 DirectByteBuffer 对象不可达被垃圾回收时,将会执行 Cleaner 实例内部的 Runnable 实例的 run 方法,用来回收堆外资源。

    展开全文
  • 引用使用

    千次阅读 2014-11-14 13:22:03
    引用变量 C++新增了一种复合类型————引用变量。引用是已定义的变量的别名。
  • 什么是引用? int a; int &b=a; 上边就是变量的引用 符号&不是去地址的含义了,去地址是在指针时的含义,这里表示引用。(这个引用不是动词,而是名词) 引用的定义:对一个数据...比较一下指针的使用: int a=30; int
  • 引用和弱引用使用场景

    千次阅读 2018-11-04 15:35:34
    引用和弱引用 SoftReference(软引用)和WeakReference(弱引用)在JAVA中对应着两个类,在SoftReference类中,有三个方法,两个构造方法和一个get方法(WekReference类似),而当应用它们指向对象时应该如下操作 ...
  • 使用StringBuilder引用问题

    千次阅读 2017-02-10 10:57:40
    使用StringBuilder 需引用命名空间 using System.Text;
  • SpringMVC使用thymeleaft解决js、css等...最近做项目,使用的是springmvc框架,前期开发各种css,js的引用使用的是相对路径。 先普及一些路径的基础知识点 二、/和./和…/的含义 “/”表示根目录开始; “./”表示当...
  • C++/C++11中左值、左值引用、右值、右值引用使用
  • 这四种级别由高到低依次为:强引用、软引用、弱引用和虚引用。但是平时我们的代码中似乎很少出现这些, 而之前还看到过一份代码中, 一个Activity中有一个静态变量持有对自己的弱引用,来达到类似的singleTas
  • 使用交叉引用引用这些编号 1.交叉引用的位置 引用–插入题注栏目的“交叉引用”,如下图所示 2. 在需要插入参考文献引用的地方使用“交叉引用” 在需要插入引用的地方点击交叉引用,类型 选 编号项,内容选 段落...
  • 使用引用参数的主要原因有两个: 程序员能修改调用函数中的数据对象 通过传递引用而不是整个数据–对象,可以提高程序的运行速度 一般的原则: 对于使用引用的值而不做修改的函数: 如果数据对象很小,如内置数据...
  • 记忆里《C++ 的设计与演化》一书提过,当初加入“引用”这个语言特性的契机是运算符重载。为了让运算符重载的语法能够更加接近内建的运算符,需要能够让一个函数返回一个左值,通俗的讲就是要能够对一个函...
  • 如何使用Mendeley添加引用

    千次阅读 2018-03-16 18:20:05
    1.将Mendeley插件装入word...在word菜单栏中找到引用3.style选择IEEE,把光标移动到需要引入文献的位置4.点击Insert Citation,选择要引用的文章5.将光标移动至文章的末尾,会发现变成斜杠6.点击Insert Bibliography...
  • 大家在写代码的时候经常会看到如下的情况: 大家都知道这是因为引入了未使用的包,所以Eclipse给出了提示,告诉你这些是无用的引用,这些无用的引用即...当某个类中存在未使用引用时,使用快捷键Ctrl+Shift+O即...
  • Java 四种引用介绍及使用场景

    万次阅读 多人点赞 2018-01-28 00:28:10
    引用是平常中使用最多的引用,强引用在程序内存不足(OOM)的时候也不会被回收,使用方式: String str = new String("str"); 这个str就是强引用。 可用场景: 地球人都知道,但是我讲不出来。 ...
  • 关于C中指针的引用,解引用与脱去解引用

    万次阅读 多人点赞 2016-10-19 11:42:44
    *,& 在指针操作中的意义 (1)* 大家都知道在写int *p 时,*可以声明一个指针。很少人知道*在C/C++中还有一个名字...需要注意的是,在变量声明的时候,*不能当做解引用使用,只是表示你声明的变量是一个指针...
  • 专业地讲,引用就是某个目标变量的别名(alias),对引用的操作就是对变量的直接操作,它们的效果是完全一样的。声明一个引用时,必须要对其初始化,将其与某个变量相关联。    引用声明完毕后,相当于目标变量有...
  • 引用WeakReference作用与使用场景

    千次阅读 2019-12-29 16:56:03
    在分析threadLocal源码时,发现有使用引用WeakReference,在之前总结GC的时候,也曾简单介绍java引用类型(《jvm GC算法类型》第6节),本文在详细总结下WeakReference的使用方法。 java4种引用类型: 强:A a=...
  • Bootstrap使用之样式引用步骤

    千次阅读 2018-07-06 10:46:32
    Bootstrap使用之样式引用步骤:1.2.3.4.5.
  • 在JDK 1.2以前的版本中,若一个对象不被任何变量引用,那么程序就无法再使用这个对象。也就是说,只有对象处于可触及(reachable)状态,程序才能使用它。从JDK 1.2版本开始,把对象的引用分为4种级别,从而使程序能...
  • 引用的概念和使用方法

    千次阅读 2018-05-21 00:40:01
    一、引用的概念 引用不是定义一个变量,而是给一个已有成员起一个别名 类型 &amp;引用变量名 = 以定义的变量名 int a = 10; int &amp;b = a; 引用 的特点 1.一个变量可以有多个成员 2.引用必须初始化...
  • C/C++何时使用引用和指针

    千次阅读 2016-08-13 11:25:53
    指针与引用看上去完全不同,但是它们似乎有相同的功能。指针与引用都是让你间接引用其他对象。你如何决定在什么时候使用指针,在什么时候使用引用呢?

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,998,015
精华内容 1,199,206
关键字:

引用使用