精华内容
下载资源
问答
  • 智能指针是C++中的一个概念,通过基于引用计数的方法,解决对象的自动释放的问题。在C++编程中,有两个很让人头痛的问题:一是忘记释放动态申请的对象从而造成内存泄露;二是对象在一个地方释放后,又在别的地方被...

    强指针与弱指针

    在Android的源代码中,经常会看到形如:sp、wp这样的类型定义,这其实是Android中的智能指针。智能指针是C++中的一个概念,通过基于引用计数的方法,解决对象的自动释放的问题。在C++编程中,有两个很让人头痛的问题:一是忘记释放动态申请的对象从而造成内存泄露;二是对象在一个地方释放后,又在别的地方被使用,从而引起内存访问错误。程序员往往需要花费很大精力进行精心设计,以避免这些问题的出现。在使用智能指针后,动态申请的内存将会被自动释放(有点类似Java的垃圾回收),不需要再使用delete来释放对象,也不需要考虑一个对象是否已经在其它地方被释放了,从而使程序编写工作减轻不少,而程序的稳定性大大提高。

    Android的智能指针相关的源代码在下面两个文件中:
    
    frameworks/base/include/utils/RefBase.h
    frameworks/base/libs/utils/RefBase.cpp
    

    Android中定义了两种智能指针类型,一种是强指针sp(strong pointer),一种是弱指针(weak pointer)。其实成为强引用和弱引用更合适一些。强指针与一般意义的智能指针概念相同,通过引用计数来记录有多少使用者在使用一个对象,如果所有使用者都放弃了对该对象的引用,则该对象将被自动销毁。

    弱指针也指向一个对象,但是弱指针仅仅记录该对象的地址,不能通过弱指针来访问该对象,也就是说不能通过弱指针来调用对象的成员函数或访问对象的成员变量。要想访问弱指针所指向的对象,需首先将弱指针升级为强指针(通过wp类所提供的promote()方法)。弱指针所指向的对象是有可能在其它地方被销毁的,如果对象已经被销毁,wp的promote()方法将返回空指针,这样就能避免出现地址访问错的情况。

    是不是很神奇?弱指针是怎么做到这一点的呢?其实说穿了一点也不复杂,原因就在于每一个可以被智能指针引用的对象都同时被附加了另外一个weakref_impl类型的对象,这个对象中负责记录对象的强指针引用计数和弱指针引用计数。这个对象是智能指针的实现内部使用的,智能指针的使用者看不到这个对象。弱指针操作的就是这个对象,只有当强引用计数和弱引用计数都为0时,这个对象才会被销毁。

    说了这么多原理,下面该看看到底智能指针该怎么使用了。假设现在有一个类MyClass,如果要使用智能指针来引用这个类的对象,那么这个类需满足下列两个前提条件:

    (1) 这个类是基类RefBase的子类或间接子类;
    (2) 这个类必须定义虚构造函数,即它的构造函数需要这样定义:
    
          virtual ~MyClass();
    
    满足了上述条件的类就可以定义智能指针了,定义方法和普通指针类似。比如普通指针是这样定义:
    
    MyClass* p_obj;
    
    智能指针是这样定义:
    
    sp<MyClass> p_obj;
    
    注意不要定义成 sp<MyClass>* p_obj。初学者容易犯这种错误,这样实际上相当于定义了一个指针的指针。尽管在语法上没有问题,但是最好永远不要使用这样的定义。
    
    定义了一个智能指针的变量,就可以象普通指针那样使用它,包括赋值、访问对象成员、作为函数的返回值、作为函数的参数等。比如:
    
       p_obj = new MyClass(); // 注意不要写成 p_obj = new sp<MyClass>
    
        sp<MyClass> p_obj2 = p_obj;
    
        p_obj->func();
    
        p_obj = create_obj();
    
        some_func(p_obj);

    注意不要试图delete一个智能指针,即 delete p_obj。不要担心对象的销毁问题,智能指针的最大作用就是自动销毁不再使用的对象。不需要再使用一个对象后,直接将指针赋值为NULL即可:

        p_obj = NULL;

    上面说的都是强指针,弱指针的定义方法和强指针类似,但是不能通过弱指针来访问对象的成员。下面是弱指针的示例:

    wp<MyClass> wp_obj = new MyClass();
    
        p_obj = wp_obj.promote(); // 升级为强指针。不过这里要用.而不是->,真是有负其指针之名啊
    
        wp_obj = NULL;

    智能指针用起来是很方便,在一般情况下最好使用智能指针来代替普通指针。但是需要知道一个智能指针其实是一个对象,而不是一个真正的指针,因此其运行效率是远远比不上普通指针的。所以在对运行效率敏感的地方,最好还是不要使用智能指针为好。

    Android C++框架层的引用计数技术

    C++中对指针的使用时很头疼的事情,一个是经常会忘记free 指针,造成内存泄露,另外一个就是野指针问题:访问已经free掉的指针。程序debug工作的相当大部分,都是花费在这。Android中通过引用计数来自动管理指针的生命周期,动态申请的内存将会在不再需要时被自动释放(有点类似Java的垃圾回收),不用程序员明确使用delete来释放对象,也不需要考虑一个对象是否已经在其它地方被释放了,从而使程序编写工作减轻不少,而程序的稳定性也大大提高。

    Android提供的引用计数技术,主要是通过RefBase类及其子类sp (strong pointer)和wp(weak pointer)实现的。

    引用计数的问题

    任何东西都不会是万能的,Android C++中的引用计数问题,和Java一样,并不能完全避免内存泄露,另外还有一个问题就是性能(overhead)问题也很突出,本文就不说了。

    使用了android的sp指针,也不能说就不需要程序员去关心指针的细节了。通常由于设计或使用的不良,更有可能导致内存无法回收,也就是内存泄露问题,甚至于还可能导致不明就里的野指针问题。而此时导致的内存使用问题,由于其具有更多的欺骗性和隐蔽性,往往更难发觉和调试。

    循环引用及其解法

    使用引用计数的智能指针管理方法中,常见的java内存泄露问题在C++中一样存在。在Android的强指针引用中,一个最常见的就是强指针的循环引用问题。而这又是程序员比较容易犯的问题:在程序员对强弱指针的理解不是很深入的情况下,想当然的认为使用了强指针,系统会根据引用计数自动收回。

    循环引用,就是对象A有个强指针,引用对象B;对象B中,也有个强指针,引用对象A;这样A和B就互锁。A对象释放B对象的引用是在本身被析构回收时,而析构回收的前提是A对象没有被引用,则需要B对象先释放,B对象释放的前提是A对象释放…如此则A和B都无法释放,这样即产生了内存泄露(内存泄漏指由于疏忽或错误造成程序未能释放已经不再使用的内存。 内存泄漏并非指内存在物理上的消失,而是应用程序分配某段内存后,由于设计错误,导致在释放该段内存之前就失去了对该段内存的控制,从而造成了内存的浪费。)。

    下面举一个内存泄漏的例子:

    namespace android{  
    
    class Bigclass : public RefBase   
    {   
    public:  
        Bigclass(char *name){  
            strcpy(mName, name);  
            ALOGD("Construct: %s", mName);  
        }  
    
        ~Bigclass(){  
            ALOGD("destruct: %s", mName);  
        }  
    
        void setStrongRefs(sp<Bigclass> b){  
            spB = b;  
        }         
    
    private:      
        sp<Bigclass> spB;  
            char mName[64];   
    };  
    
    }  

    该类非常简单,只有一个sp指针和一个name成员。循环引用示例:

    void testStrongCrossRef(){  
        sp<Bigclass> A = new Bigclass("testStrongClassA");  
        sp<Bigclass> B = new Bigclass("testStrongClassB");  
    
        A->setStrongRefs(B);  
        B->setStrongRefs(A);  
    }  
    
    int main(){  
        ALOGD("Start testStrongClasses..");    
        testStrongCrossRef();  
        ALOGD("testStrongClasses Should be destructed!!");  
    
        return 0;  
    }

    输出的结果,如预期,对象没有被释放,泄露了:

    D/TEST    ( 1552): Start testStrongClasses..  
    D/TEST    ( 1552): Construct: testStrongClassA  
    D/TEST    ( 1552): Construct: testStrongClassB  
    D/TEST    ( 1552): testStrongClasses Should be destructed!!  

    为了解决这一问题,Android在又引入了弱指针,弱指针并不能通过引用计数来控制所引用对象的生命周期,这样就可以消除上例中的引用环路问题,使得问题解决。我们将上述的类稍作修改,增加了弱引用的接口:

    namespace android{  
    
    class Bigclass : public RefBase   
    {   
    public:  
        Bigclass(char *name){  
            strcpy(mName, name);  
            ALOGD("Construct: %s", mName);  
        }  
    
        ~Bigclass(){  
            ALOGD("destruct: %s", mName);  
        }  
    
        void setStrongRefs(sp<Bigclass> b){  
            spB = b;  
        }         
    
        void setWeakRefs(sp<Bigclass> b){  
            wpB = b;  
        }    
    
    private   
        sp<Bigclass> spB;  
        wp<Bigclass> wpB;  
            char mName[64];   
    };  
    
    } 

    先来测试一下,将上例中的强指针换成弱指针,会是什么情况:

    void testWeakCrossRef(){  
     sp<Bigclass> A = new Bigclass("testWeakClassA");  
     sp<Bigclass> B = new Bigclass("testWeakClassB");  
    
      A->setWeakRefs(B);  
      B->setWeakRefs(A);  
    }  

    输出结果:

    D/TEST    ( 2889): Start testWeakClass ..  
    D/TEST    ( 2889): Construct: testWeakClassA  
    D/TEST    ( 2889): Construct: testWeakClassB  
    D/TEST    ( 2889): destruct: testWeakClassB  
    D/TEST    ( 2889): destruct: testWeakClassA  
    D/TEST    ( 2889): testWeakClass Should be destructed!!  

    在出了testWeakClassA和testWeakClassB在对象A和B出了作用域后,没有强引用了,两个对象都释放了,这个符合预期。
    这里testWeakClassA和testWeakClassB之间的引用关系,全部都是弱引用,因此二者间的生命周期互不相干,这里二者用sp对象A和B与创建一般的栈对象 Bigclass A, Bigclass B 的生命周期一样。

    Android中,最常用的肯定不是下面两种:

    1.强强引用——互不相让,互相绑死,这是绝对禁止的。
    2.弱弱引用——互不相干,各管生死。这个对于想要使用引用计数自动管理对象生命周期来说,没什么用处。

    最常用的一般是强弱引用关系。强弱引用需要是有从属关系的,具体那个类是用sp引用,哪个是用wp引用,要看设计的逻辑了。

    测试示例:

    void testCrossRef(){  
     sp<Bigclass> A = new Bigclass("testNormalClassA");  
     sp<Bigclass> B = new Bigclass("testNormalClassB");  
    
      A->setStrongRefs(B);  
      B->setWeakRefs(A);  
    }  

    输出结果:

    D/TEST    ( 2889): Start test Normal pointer reference ..  
    D/TEST    ( 2889): Construct: testNormalClassA  
    D/TEST    ( 2889): Construct: testNormalClassB  
    D/TEST    ( 2889): destruct: testNormalClassA  
    D/TEST    ( 2889): destruct: testNormalClassB  
    D/TEST    ( 2889): Test Normal pointer reference Should be destructed!!  

    这种情况下,消除了循环引用,没有了内存泄露问题。 和上一个弱弱引用的例子比较,这里testNormalClassB的析构在testWeakClassA之后,testWeakClassB的生命周期是受testWeakClassA控制的,只有testWeakClassA析构,testWeakClassB才会析构。(上面的弱弱引用的测例,说明在无干预的情况下,应该是testWeakClassB先析构的)

    对于强弱指针的使用,使用弱指针是需要特别注意,弱指针指向的对象,可能已经被销毁了,使用前需要通过promote()方法探测一下。

    野指针问题

    强弱引用的问题,相信大多数Android程序员都明白,这里主要要强调一点就是:使用的时候要小心,一不小心可能就出错,举个例子:

    我们在刚才定义的BigClass中增加另外一个构造函数:

    Bigclass(char *name, char * other){  
        strcpy(mName, name);  
        ALOGD("Construct another: %s", mName);  
        setWeakRefs(this);  
    }  

    这个构造函数,是将本对象中wp类型成员变量的用自己构造,也就是wp指针指向自己,这是允许的。

    在写个测试用例:

    void testCrash(){  
        sp<Bigclass> A = new Bigclass("testCrashA", "testCrash");  
        sp<Bigclass> B = new Bigclass("testCrashB");  
        A->setWeakRefs(B);  
        B->setWeakRefs(A);  
    }  

    输出结果:

    D/TEST    ( 3709): Construct another: testCrashA  
    D/TEST    ( 3709): destruct: testCrashA  
    D/TEST    ( 3709): Construct: testCrashB  
    D/TEST    ( 3709): destruct: testCrashB  

    好像没有什么问题,程序也没有崩溃呀?
    没有崩溃,那是幸运,因为这个测试代码和上下文太简单了。 我们看下输出就知道了:testCrashB对象构造的时候, testClassA已经析构了!!!!

    也就是说,A对象,在其创建后,马上就消亡了,testCrash()方法中操作的A对象所指向的,都是野指针!!!

    为何会出现野指针?问题出在刚才定义的构造函数Bigclass(char name, char other)中。

    setWeakRefs(this);  

    这里的this是一个Bigclass *类型的,这样在参数压栈的时候需要构建一个临时的sp强指针对象,调用完成后,该对象析构。该sp对象通过sp的sp

    Bigclass(char *name, char * other){  
        ALOGD("start Construct another: %s,", mName);  
        strcpy(mName, name);  
        setWeakRefs(this);  
        ALOGD("end Construct another: %s,", mName);  
    }  

    看一下析构是否在start和end之间。跑一下,你会有意想不到的打印

    这里可以给一条规则:
    绝对不能在创建的RefBase对象还没有被一个确定的长作用域sp对象引用前,通过局部短作用域sp指针引用。

    关于sp和wp:

    C++中,sp或wp是一个对象,不是指针。
    sp或wp引用的对象,是从堆上new出来的
    sp或wp的作用,只是让用户不用太关注delete的调用,sp在析构时,检查堆上对象的引用情况,如果没有别的引用,sp析构自动帮忙调用
    wp主要是为解决循环引用的问题。当类比较复杂时,循环引用会很常见。

    转自:

    http://blog.csdn.net/freshui/article/details/9049193
    http://blog.csdn.net/typename/article/details/5808473

    展开全文
  • 强弱引用

    2015-01-28 16:47:53
    字符串常量是强引用, 对象是弱引用,使用弱引用管理对象,在内存不够下,通过手动调用GC实现节约开支目的     案例1:   /** * 引用分类:强、软、弱、虚 * 强与弱引用 * @author Administrator * ...

     

     

    字符串常量是强引用, 对象是弱引用,使用弱引用管理对象,在内存不够下,通过手动调用GC实现节约开支目的

     

     

    案例1:

     

    /**
     * 引用分类:强、软、弱、虚
     * 强与弱引用
     * @author Administrator
     *
     */
    public class RefDemo {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    	
    		//testStrong();
    		testWeak();
    		
    	}
    	/**
    	 * gc运行前:sina is very good
           gc运行后:null
    	 */
    	private static void testWeak() {
    		
    		//字符串对象
    		String str =new String("sina is very good");
    		//弱引用 管理 对象
    		WeakReference<String> wr =new WeakReference<String>(str);
    		System.out.println("gc运行前:"+wr.get());
    		//断开引用
    		str =null;
    		//通知回收
    		System.gc();
    		System.runFinalization();
    		//对象被回收
    		System.out.println("gc运行后:"+wr.get());
    	}
    	/**
    	 * 结果:
    	 * gc运行前:sina is very good
           gc运行后:sina is very good
    
    	 */
    	public static void testStrong(){
    		//字符串常量池  共享(不能回收)
    		String str ="sina is very good";
    		//弱引用 管理 对象
    		WeakReference<String> wr =new WeakReference<String>(str);
    		System.out.println("gc运行前:"+wr.get());
    		//断开引用
    		str =null;
    		//通知回收
    		System.gc();
    		System.runFinalization();
    		System.out.println("gc运行后:"+wr.get());
    	}
    
    }

     

     

    案例2 WeakHashMap的使用:

     

    	public static void main(String[] args) {
    		WeakHashMap<String,String> map =new WeakHashMap<String,String>();
    		//测试数据
    		//常量池对象,不会回收  属于强引用
    		map.put("abc", "a");
    		map.put("d", "test");
    		//gc运行 已被回收  
    		map.put(new String("sina"), "c");
    		map.put(new String("dsf"), "d");
    		
    		//通知回收
    		System.gc();
    		System.runFinalization();
    		
    		System.out.println(map.size()); // 结果是2   
    	}

     

     

     

    展开全文
  • iOS 强弱引用

    2016-03-23 10:23:30
    QF——关于iOS的强引用,弱引用及strong,retain,copy,weak,assignd的关系 时间 2015-05-02 14:10:00 博客园精华区 原文 http://www.cnblogs.com/wangerxiansheng/p/4471819.html 主题 iOS开发 强...

    QF——关于iOS的强引用,弱引用及strong,retain,copy,weak,assignd的关系

    强引用和弱引用:

    我们已经知道OC中的内存管理是通过“引用计数器”来实现的。一个对象的生命周期取决于它是否还被其他对象引用(是否retainCount=0)。但在有些情况下,我们并不希望对象的销毁时间由是否被其他对象引用来决定,而是这个对象本该是什么时候销毁就什么时候被销毁。这时,我们得引入“强引用”和“弱引用”的概念。

    强引用:当前对象被其他对象引用时,会执行retain操作,引用计数器+1。当retainCount=0时,该对象才会被销毁。因为我们要进行对象的内存管理,所以这是默认的引用方式。(默认是强引用)

    弱引用:当前对象的生命周期不被是否由其他对象引用限制,它本该什么时候销毁就什么时候被销毁。即使它的引用没断,但是当它的生存周期到了时就会被销毁。

    在定义属性时,若声明为retain类型的,则就是强引用;若声明为assign类型的,则就是弱引用。后来内存管理都由ARC来完成后,若是强引用,则就声明为strong;若是弱引用,则就声明为weak。

    所以说,retain和strong是一致的(声明为强引用);assign和weak是基本一致的(声明为弱引用)。 之所以说它俩是基本一致是因为它俩还是有所不同的,weak严格的说应当叫“  归零弱引用 ”,即当对象被销毁后,会自动的把它的指针置为nil,这样可以防止野指针错误。而assign销毁对象后不会把该对象的指针置nil,对象已经被销毁,但指针还在痴痴的指向它,这就成了野指针,这是比较危险的。 

    避免“强引用循环“的僵局:

    默认的引用方式是强引用,但上面说了有时我们还得使用弱引用,那是什么情况呢? 

    答案,强引用循环:A对象强引用了B对象,B对象也强引用了A。因为都是强引用,也就是无论是A是B都要在对方的引用断了后才能销毁,但要断了引用,就必须对方对象销毁。就会出现这种僵局,为了避免出现这种情况,就应该有一个对象“示弱”,使其为“弱引用”。  

    比较常见的,视图中的父子视图之间的引用:父视图强引用子视图,子视图弱引用父视图。

    总结:由于要进行内存管理的缘故,OC里的引用默认都是强引用,但为了避免出现”强引用循环僵局“,所以有了弱引用(assign)。

    关于copy:  参考链接

    retain和strong都是  指针拷贝。 当有其他对象引用当前对象时,会拷贝一份当前对象的地址,这样它就也指向当前对象了。所以,还是同一个对象,只是retainCount+1; 

    而copy则是  内容拷贝。 是实实在在的拷贝一个新的对象,拷贝了它的内存内容,成为一个新的对象(retainCount=1)。 

    深拷贝(mutableCopy)和浅拷贝(copy):

    深拷贝就是内容拷贝,浅拷贝就是指针拷贝。

    在OC中,若要进行对象的拷贝,则该对象所属的类必须遵守NSCopying和NSMutableCopy协议,并重写copyWithZone:和mutableCopyWithZone:方法。而系统原生类,之所以可以直接进行拷贝是因为它已帮我们自动做了这些事

    在Objective-C的ARC模式中, 

    ?
    1
    id obj1 = [[NSObject alloc] init];
    这里虽然没有显示的声明为__strong,但是Objective-C默认声明的一个对象就为__strong,即: 
    ?
    1
    id obj1 = [[NSObject alloc] init];
    和 
    ?
    1
    id __strong obj1 = [[NSObject alloc] init];

    是等价的。

    在强引用中,有时会出现循环引用的情况,这时就需要弱引用来帮忙(__weak)。 

    强引用持有对象,弱引用不持有对象。 

    强引用可以释放对象,但弱引用不可以,因为弱引用不持有对象,当弱引用指向一个强引用所持有的对象时,当强引用将对象释放掉后,弱引用会自动的被赋值为nil,即弱引用会自动的指向nil。 

    下面用代码来说明: 

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    //
    //  main.m
    //  ARC中的强引用和弱引用
    //
    //  Created by on 15/3/31.
    //  Copyright (c) 2015年 apple. All rights reserved.
    //
     
    #import <Foundation/Foundation.h>
     
    int main( int argc, const char * argv[]) {
         @autoreleasepool {
             id __weak obj0 = nil;
             if (YES) {
                 id obj1 = [[NSObject alloc] init];
                 obj0 = obj1;
                 NSLog(@ "obj0: %@" , obj0);
             }
             NSLog(@ "obj0: %@" , obj0);
         }
         return 0;
    }
     
    /*
      *  输出结果
      *  obj0: <NSObject: 0x1003066c0>
      *  obj0: (null)
      *
      *  因为obj1生成的默认的为强引用(__strong),在超出if的作用域之后,obj1所持有的对象被释放,
      *  obj0为弱引用,所以obj0不持有对象,在obj1对象释放后,obj0自动的被赋值为nil
      *  弱引用的特性是,不持有对象,即便是写成id __weak obj1 = [[NSObject alloc] init];
      *  此代码系统会给与警告,因为这里obj1被声明成弱引用,那么在赋值之后,alloc出来的对象会被立即释放。

    展开全文
  • JVM强弱引用及算法

    2019-07-07 15:45:24
    3.弱引用:它也是用来描述废墟对象,但她的强度比软引用更若邪,被弱引用关联的对象只能生存到下一次垃圾回收器发生之前,当垃圾回收器发生工作的时,无论当前内存是否足够,都会回收掉只被弱引用关联的对象 ...
    1. 停止-复制算法:
      将可用的内存按容量划分为大小相等的两块(from,to),每次只是用其中一块(总有一块是空的【to区域】)。当这一苦熬的内存用完了,就将还存活着的对象复制到另外一块上面,然后把已使用过的内存空间一次清理完。
      HotSpot虚拟机默认Eden和Survivor大小的比例是8:1,也就是每次新生代中可用的内存空间为整个新生代容量的90%,只有10%的内存时被浪费的。
      缺点:浪费内存空间,如果对象存活率较高时要执行较多的复制操作,效率降低。
      图解:有一块内存区域是空的,一般是to区域。保留区域每次回收后都因为复制的时候让他们变为连续的地址空间,所有不产生内存碎片。
      在这里插入图片描述
    2. 标记-清除算法:
      先标记出所有需要回收的对象,在标记完成后统一回收所有被标记的对象。
      缺点:回收了被标记的对象后,由于未经过整理,所以导致很多内存碎片
      图解:绿色是被标记为可回收的,当回收后,未使用的内存空间非常零碎,产生内存碎片。
      在这里插入图片描述
    3. 标记-整理算法:
      标记整理算法的“标记”过程和标记-清除算法一致,只是后面并不是直接对可回收对象进行整理,而是让所有存活的对象都向一段移动,然后直接清理掉端边界意外的内存。
      图解:由于标记后继续整理,可以很明显的看出未使用的地址空间都是连续的,不会产生内存碎片。
      在这里插入图片描述
      垃圾回收是JAVA虚拟机垃圾回收期提供的一种用于在空闲时间不定时回收无任何对象引用的对象占据的内存空间的一种机制

    引用:如果Reference类型的数据中存储的数值代表的是另外一块内存的其实地址,就称这块内存代表着一个引用

    1.强引用:只要强引用还存在,垃圾回收期就永远不会回收掉被引用的对象

    2.软引用:它用来描述一些可能还有用,但并非必须的对象,在系统内存不够用时,这类引用关联的对象将被垃圾回收器回收

    3.弱引用:它也是用来描述废墟对象,但她的强度比软引用更若邪,被弱引用关联的对象只能生存到下一次垃圾回收器发生之前,当垃圾回收器发生工作的时,无论当前内存是否足够,都会回收掉只被弱引用关联的对象

    4.虚引用:最弱的一种引用,不会对对象的生命周期造成任何印象,也无法通过虚引用来取得一个对象的实例,把对象设置虚引用关联的唯一目的是希望能在这个对象呗收集器回收时收到一个系统通知。

    JAVA的垃圾回收器

    1.串行垃圾回收器(年轻代/老年代)
    2.并行垃圾回收器(年轻代/老年代)
    3.ParNew(串行的多线程版本)
    4.CMS(WEB项目常用的垃圾回收器)
    5.G1(年轻代老年代都可用,减少用户的响应时间,给用户良好的体验)

    展开全文
  • Android 强弱引用

    2020-03-08 14:51:58
    Android 强弱引用 软件:Source Insight 4.0、starUml 代码目录: system/core/include/utils/RefBase.h system/core/include/utils/StrongPointer.h system/core/libutils/RefBase.cpp 一、简介 从media服务的...
  • 基础篇 iOS 强弱引用

    2017-10-20 16:35:00
    引用可以释放对象,但弱引用不可以,因为弱引用不持有对象,当弱引用指向一个强引用所持有的对象时,当强引用将对象释放掉后,弱引用会自动的被赋值为nil,即弱引用会自动的指向nil。  下面用代码来说明:  ...
  • Swift入门教程17-ARC与强弱引用

    千次阅读 2014-11-21 21:50:00
    全称自动引用计数,是一种内存管理机制。当一块内存的强引用的数目等于0的时候,则这块内存将会被释放。 由于在Swift中,枚举和结构体都是值类型,不通过引用方式进行存储和传递,所以Swift中只有类的实例会进行自动...
  • C语言 强弱符号,强弱引用

    千次阅读 2016-12-09 16:46:09
    首先我表示很悲剧,在看《程序员的自我修养–链接、装载与库》之前我竟不知道C有强符号、弱符号、强引用和弱引用。在看到3.5.5节弱符号和强符号时,我感觉有些困惑,所以写下此篇,希望能和同样感觉的朋友交流也希望...
  • 为什么要有强弱指针引用? class A { shared_ptr b_ptr; } class B { shared_ptr a_ptr; } void test() { shared_ptr a_obj=shared_ptr(new A); shared_ptr  b_obj=shared_ptr(new B); ...
  • iOS强弱引用

    2014-04-10 11:04:13
    保留一个对象创建了一个对该对象的“强”引用。一个对象只有在它的所有强引用都被释放后才能被回收。因此,一个对象的生命周期取决于其强引用的所有者。在某些情况下,这种行为可能并不理想。您可能想要引用一个对象...
  • 经常见朋友们提起 “资源占用” 与 “垃圾回收”机制, 此类情况有常常伴随事件机制与显示列表相关问题,还有诸如此类的强弱引用的问题,关系错综复杂,令人困惑不小。在经过一番整理和测试研究后决定拿出来和大家...
  • 关于oc中的强弱引用

    2014-09-23 18:20:56
    引用和弱引用的广义区别

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,786
精华内容 3,514
关键字:

强弱引用