- 浏览: 399424 次
文章分类
最新评论
-
a597525618:
能不能提供全部的代码给我?谢谢咯/
百度地图BMap API的应用实例 -
天然呆的大蘑菇:
我用类似的方法,总是遇到内存溢出,楼主是如何解决这个问题的呢 ...
android UI进阶之用ViewPager实现欢迎引导页面 -
northsea2006:
怎么用呢?
HTML嵌套Flash播放视频 -
chengchengiloveyou:
...
9件创业教会我的事 -
android_mylove:
testvon 写道最近也在用JDBC,感觉是比HIBERNA ...
编码阶段的一些问题
Android 智能指针原理
Android系统的运行时库层代码是用C++来编写的,用C++来写代码最容易出错的地方就是指针了,一旦使用不当,轻则造成内存泄漏,重则造成系统崩溃。不过系统为我们提供了智能指针,避免出现上述问题,本文将系统地分析Android系统智能指针(轻量级指针、强指针和弱指针)的实现原理。
一、内存泄露与智能指针
在使用C++来编写代码的过程中,指针使用不当造成内存泄漏一般就是因为new了一个对象并且使用完之后,忘记了delete这个对象,而造成系统崩溃。一般就是因为一个地方delete了这个对象之后,其它地方还在继续使原来指向这个对象的指针。
为了避免出现上述问题,一般的做法就是使用引用计数的方法,每当有一个指针指向了一个new出来的对象时,就对这个对象的引用计数增加1,每当有一个指针不再使用这个对象时,就对这个对象的引用计数减少1,每次减1之后,如果发现引用计数值为0时,那么,就要delete这个对象了,这样就避免了忘记delete对象或者这个对象被delete之后其它地方还在使用的问题了。
但是,如何实现这个对象的引用计数呢?肯定不是由开发人员来手动地维护了,要开发人员时刻记住什么时候该对这个对象的引用计数加1,什么时候该对这个对象的引用计数减1,一来是不方便开发,二来是不可靠,一不小心哪里多加了一个1或者多减了一个1,就会造成灾难性的后果。这时候,智能指针就粉墨登场了。
首先,智能指针是一个对象,不过这个对象代表的是另外一个真实使用的对象,当智能指针指向实际对象的时候,就是智能指针对象创建的时候,当智能指针不再指向实际对象的时候,就是智能指针对象销毁的时候,我们知道,在C++中,对象的创建和销毁时会分别自动地调用对象的构造函数和析构函数,这样,负责对真实对象的引用计数加1和减1的工作就落实到智能指针对象的构造函数和析构函数的身上了,这也是为什么称这个指针对象为智能指针的原因。
在计算机科学领域中,提供垃圾收集GC(Garbage Collection)功能的系统框架,即提供对象托管功能的系统框架,例如Java应用程序框架,也是采用上述的引用计数技术方案来实现的,然而,简单的引用计数技术不能处理系统中对象间循环引用的情况。考虑这样的一个场景,系统中有两个对象A和B,在对象A的内部引用了对象B,而在对象B的内部也引用了对象A。当两个对象A和B都不再使用时,垃圾收集系统会发现无法回收这两个对象的所占据的内存的,因为系统一次只能收集一个对象,而无论系统决定要收回对象A还是要收回对象B时,都会发现这个对象被其它的对象所引用,因而就都回收不了,这样就造成了内存泄漏。
这样,就要采取另外的一种引用计数技术了,即对象的引用计数同时存在强引用和弱引用两种计数,例如,Apple公司提出的Cocoa框架,当父对象要引用子对象时,就对子对象使用强引用计数技术,而当子对象要引用父对象时,就对父对象使用弱引用计数技术,而当垃圾收集系统执行对象回收工作时,只要发现对象的强引用计数为0,而不管它的弱引用计数是否为0,都可以回收这个对象,但是,如果我们只对一个对象持有弱引用计数,当我们要使用这个对象时,就不直接使用了,必须要把这个弱引用升级成为强引用时,才能使用这个对象,在转换的过程中,如果对象已经不存在,那么转换就失败了,这时候就说明这个对象已经被销毁了,不能再使用了。
二、Android 智能指针
了解了这些背景知识后,我们就可以进一步学习Android系统的智能指针的实现原理了。Android系统提供了强大的智能指针技术供我们使用,这些智能指针实现方案既包括简单的引用计数技术,也包括了复杂的引用计数技术,即对象既有强引用计数,也有弱引用计数,对应地,这三种智能指针分别就称为轻量级指针(Light Pointer)、强指针(Strong Pointer)、弱指针(Weak Pointer)。无论是轻量级指针,还是强指针和弱指针,它们的实现框架都是一致的,即由对象本身来提供引用计数器,但是它不会去维护这个引用计数器的值,而是由智能指针来维护,就好比是对象提供素材,但是具体怎么去使用这些素材,就交给智能指针来处理了。由于不管是什么类型的对象,它都需要提供引用计数器这个素材,在C++中,我们就可以把这个引用计数器素材定义为一个公共类,这个类只有一个成员变量,那就是引用计数成员变量,其它提供智能指针引用的对象,都必须从这个公共类继承下来,这样,这些不同的对象就天然地提供了引用计数器给智能指针使用了。总的来说就是我们在实现智能指会的过程中,第一是要定义一个负责提供引用计数器的公共类,第二是我们要实现相应的智能指针对象类,后面我们会看到这种方案是怎么样实现的。
接下来,我们就先介绍轻量级指针的实现原理,然后再接着介绍强指针和弱指针的实现原理。
1. 轻量级指针
先来看一下实现引用计数的类LightRefBase,它定义在frameworks/base/include/utils/RefBase.h文件中:
- template<classT>
- classLightRefBase
- {
- public:
- inlineLightRefBase():mCount(0){}
- inlinevoidincStrong(constvoid*id)const{
- android_atomic_inc(&mCount);
- }
- inlinevoiddecStrong(constvoid*id)const{
- if(android_atomic_dec(&mCount)==1){
- deletestatic_cast<constT*>(this);
- }
- }
- //!DEBUGGINGONLY:Getcurrentstrongrefcount.
- inlineint32_tgetStrongCount()const{
- returnmCount;
- }
- protected:
- inline~LightRefBase(){}
- private:
- mutablevolatileint32_tmCount;
- };
前面说过,要实现自动引用计数,除了要有提供引用计数器的基类外,还需要有智能指针类。在Android系统中,配合LightRefBase引用计数使用的智能指针类便是sp了,它也是定义在frameworks/base/include/utils/RefBase.h文件中:
- template<typenameT>
- classsp
- {
- public:
- typedeftypenameRefBase::weakref_typeweakref_type;
- inlinesp():m_ptr(0){}
- sp(T*other);
- sp(constsp<T>&other);
- template<typenameU>sp(U*other);
- template<typenameU>sp(constsp<U>&other);
- ~sp();
- //Assignment
- sp&operator=(T*other);
- sp&operator=(constsp<T>&other);
- template<typenameU>sp&operator=(constsp<U>&other);
- template<typenameU>sp&operator=(U*other);
- //!SpecialoptimizationforusebyProcessState(andnobodyelse).
- voidforce_set(T*other);
- //Reset
- voidclear();
- //Accessors
- inlineT&operator*()const{return*m_ptr;}
- inlineT*operator->()const{returnm_ptr;}
- inlineT*get()const{returnm_ptr;}
- //Operators
- COMPARE(==)
- COMPARE(!=)
- COMPARE(>)
- COMPARE(<)
- COMPARE(<=)
- COMPARE(>=)
- private:
- template<typenameY>friendclasssp;
- template<typenameY>friendclasswp;
- //Optimizationforwp::promote().
- sp(T*p,weakref_type*refs);
- T*m_ptr;
- };
- template<typenameT>
- sp<T>::sp(T*other)
- :m_ptr(other)
- {
- if(other)other->incStrong(this);
- }
- template<typenameT>
- sp<T>::sp(constsp<T>&other)
- :m_ptr(other.m_ptr)
- {
- if(m_ptr)m_ptr->incStrong(this);
- }
最后,看一下析构函数:
- template<typenameT>
- sp<T>::~sp()
- {
- if(m_ptr)m_ptr->decStrong(this);
- }
轻量级智能指针的实现原理大概就是这样了,比较简单,下面我们再用一个例子来说明它的用法。
2. 轻量级指针的用法
参考在Ubuntu上为Android系统内置C可执行程序测试Linux内核驱动程序一文,我们在external目录下建立一个C++工程目录lightpointer,它里面有两个文件,一个lightpointer.cpp文件,另外一个是Android.mk文件。
源文件lightpointer.cpp的内容如下:
- #include<stdio.h>
- #include<utils/RefBase.h>
- usingnamespaceandroid;
- classLightClass:publicLightRefBase<LightClass>
- {
- public:
- LightClass()
- {
- printf("ConstructLightClassObject.");
- }
- virtual~LightClass()
- {
- printf("DestoryLightClassObject.");
- }
- };
- intmain(intargc,char**argv)
- {
- LightClass*pLightClass=newLightClass();
- sp<LightClass>lpOut=pLightClass;
- printf("LightRefCount:%d.\n",pLightClass->getStrongCount());
- {
- sp<LightClass>lpInner=lpOut;
- printf("LightRefCount:%d.\n",pLightClass->getStrongCount());
- }
- printf("LightRefCount:%d.\n",pLightClass->getStrongCount());
- return0;
- }
编译脚本文件Android.mk的内容如下:
- LOCAL_PATH:=$(callmy-dir)
- include$(CLEAR_VARS)
- LOCAL_MODULE_TAGS:=optional
- LOCAL_MODULE:=lightpointer
- LOCAL_SRC_FILES:=lightpointer.cpp
- LOCAL_SHARED_LIBRARIES:=\
- libcutils\
- libutils
- include$(BUILD_EXECUTABLE)
- USER-NAME@MACHINE-NAME:~/Android$mmm./external/lightpointer
- USER-NAME@MACHINE-NAME:~/Android$makesnod
- USER-NAME@MACHINE-NAME:~/Android$adbshell
- root@android:/#cdsystem/bin/
- root@android:/system/bin#./lightpointer
- ConstructLightClassObject.
- LightRefCount:1.
- LightRefCount:2.
- LightRefCount:1.
- DestoryLightClassObject.
这里可以看出,程序一切都是按照我们的设计来运行,这也验证了我们上面分析的轻量级智能指针的实现原理。
3. 强指针
强指针所使用的引用计数类为RefBase,它LightRefBase类要复杂多了,所以才称后者为轻量级的引用计数基类吧。我们先来看看RefBase类的实现,它定义在frameworks/base/include/utils/RefBase.h文件中:
- classRefBase
- {
- public:
- voidincStrong(constvoid*id)const;
- voiddecStrong(constvoid*id)const;
- voidforceIncStrong(constvoid*id)const;
- //!DEBUGGINGONLY:Getcurrentstrongrefcount.
- int32_tgetStrongCount()const;
- classweakref_type
- {
- public:
- RefBase*refBase()const;
- voidincWeak(constvoid*id);
- voiddecWeak(constvoid*id);
- boolattemptIncStrong(constvoid*id);
- //!ThisisonlysafeifyouhavesetOBJECT_LIFETIME_FOREVER.
- boolattemptIncWeak(constvoid*id);
- //!DEBUGGINGONLY:Getcurrentweakrefcount.
- int32_tgetWeakCount()const;
- //!DEBUGGINGONLY:Printreferencesheldonobject.
- voidprintRefs()const;
- //!DEBUGGINGONLY:Enabletrackingforthisobject.
- //enable--enable/disabletracking
- //retain--whentrackingisenable,iftrue,thenwesaveastacktrace
- //foreachreferenceanddereference;whenretain==false,we
- //matchupreferencesanddereferencesandkeeponlythe
- //outstandingones.
- voidtrackMe(boolenable,boolretain);
- };
- weakref_type*createWeak(constvoid*id)const;
- weakref_type*getWeakRefs()const;
- //!DEBUGGINGONLY:Printreferencesheldonobject.
- inlinevoidprintRefs()const{getWeakRefs()->printRefs();}
- //!DEBUGGINGONLY:Enabletrackingofobject.
- inlinevoidtrackMe(boolenable,boolretain)
- {
- getWeakRefs()->trackMe(enable,retain);
- }
- protected:
- RefBase();
- virtual~RefBase();
- //!FlagsforextendObjectLifetime()
- enum{
- OBJECT_LIFETIME_WEAK=0x0001,
- OBJECT_LIFETIME_FOREVER=0x0003
- };
- voidextendObjectLifetime(int32_tmode);
- //!FlagsforonIncStrongAttempted()
- enum{
- FIRST_INC_STRONG=0x0001
- };
- virtualvoidonFirstRef();
- virtualvoidonLastStrongRef(constvoid*id);
- virtualboolonIncStrongAttempted(uint32_tflags,constvoid*id);
- virtualvoidonLastWeakRef(constvoid*id);
- private:
- friendclassweakref_type;
- classweakref_impl;
- RefBase(constRefBase&o);
- RefBase&operator=(constRefBase&o);
- weakref_impl*constmRefs;
- };
RefBase类的成员变量mRefs的类型为weakref_impl指针,它实现在frameworks/base/libs/utils/RefBase.cpp文件中:
- classRefBase::weakref_impl:publicRefBase::weakref_type
- {
- public:
- volatileint32_tmStrong;
- volatileint32_tmWeak;
- RefBase*constmBase;
- volatileint32_tmFlags;
- #if!DEBUG_REFS
- weakref_impl(RefBase*base)
- :mStrong(INITIAL_STRONG_VALUE)
- ,mWeak(0)
- ,mBase(base)
- ,mFlags(0)
- {
- }
- voidaddStrongRef(constvoid*/*id*/){}
- voidremoveStrongRef(constvoid*/*id*/){}
- voidaddWeakRef(constvoid*/*id*/){}
- voidremoveWeakRef(constvoid*/*id*/){}
- voidprintRefs()const{}
- voidtrackMe(bool,bool){}
- #else
- weakref_impl(RefBase*base)
- :mStrong(INITIAL_STRONG_VALUE)
- ,mWeak(0)
- ,mBase(base)
- ,mFlags(0)
- ,mStrongRefs(NULL)
- ,mWeakRefs(NULL)
- ,mTrackEnabled(!!DEBUG_REFS_ENABLED_BY_DEFAULT)
- ,mRetain(false)
- {
- //LOGI("NEWweakref_impl%pforRefBase%p",this,base);
- }
- ~weakref_impl()
- {
- LOG_ALWAYS_FATAL_IF(!mRetain&&mStrongRefs!=NULL,"Strongreferencesremain!");
- LOG_ALWAYS_FATAL_IF(!mRetain&&mWeakRefs!=NULL,"Weakreferencesremain!");
- }
- voidaddStrongRef(constvoid*id)
- {
- addRef(&mStrongRefs,id,mStrong);
- }
- voidremoveStrongRef(constvoid*id)
- {
- if(!mRetain)
- removeRef(&mStrongRefs,id);
- else
- addRef(&mStrongRefs,id,-mStrong);
- }
- voidaddWeakRef(constvoid*id)
- {
- addRef(&mWeakRefs,id,mWeak);
- }
- voidremoveWeakRef(constvoid*id)
- {
- if(!mRetain)
- removeRef(&mWeakRefs,id);
- else
- addRef(&mWeakRefs,id,-mWeak);
- }
- voidtrackMe(booltrack,boolretain)
- {
- mTrackEnabled=track;
- mRetain=retain;
- }
- ......
- private:
- structref_entry
- {
- ref_entry*next;
- constvoid*id;
- #ifDEBUG_REFS_CALLSTACK_ENABLED
- CallStackstack;
- #endif
- int32_tref;
- };
- voidaddRef(ref_entry**refs,constvoid*id,int32_tmRef)
- {
- if(mTrackEnabled){
- AutoMutex_l(mMutex);
- ref_entry*ref=newref_entry;
- //Referencecountatthetimeofthesnapshot,butbeforethe
- //update.Positivevaluemeansweincrement,negative--we
- //decrementthereferencecount.
- ref->ref=mRef;
- ref->id=id;
- #ifDEBUG_REFS_CALLSTACK_ENABLED
- ref->stack.update(2);
- #endif
- ref->next=*refs;
- *refs=ref;
- }
- }
- voidremoveRef(ref_entry**refs,constvoid*id)
- {
- if(mTrackEnabled){
- AutoMutex_l(mMutex);
- ref_entry*ref=*refs;
- while(ref!=NULL){
- if(ref->id==id){
- *refs=ref->next;
- deleteref;
- return;
- }
- refs=&ref->next;
- ref=*refs;
- }
- LOG_ALWAYS_FATAL("RefBase:removingid%ponRefBase%p(weakref_type%p)thatdoesn'texist!",
- id,mBase,this);
- }
- }
- ......
- MutexmMutex;
- ref_entry*mStrongRefs;
- ref_entry*mWeakRefs;
- boolmTrackEnabled;
- //Collectstacktracesonaddrefandremoveref,insteadofdeletingthestackreferences
- //onremoverefthatmatchtheaddressones.
- boolmRetain;
- ......
- #endif
- };
- #if!DEBUG_REFS
- ......
- #else
- #else
- ......
- #endif
- structref_entry
- {
- ref_entry*next;
- constvoid*id;
- #ifDEBUG_REFS_CALLSTACK_ENABLED
- CallStackstack;
- #endif
- int32_tref;
- };
总的来说,weakref_impl类只要提供了以下四个成员变量来维护对象的引用计数:
- volatileint32_tmStrong;
- volatileint32_tmWeak;
- RefBase*constmBase;
- volatileint32_tmFlags;
- //!FlagsforextendObjectLifetime()
- enum{
- OBJECT_LIFETIME_WEAK=0x0001,
- OBJECT_LIFETIME_FOREVER=0x0003
- };
说了这多,RefBase类给人的感觉还是挺复杂的,不要紧,我们一步步来,先通过下面这个图来梳理一下这些类之间的关系:
从这个类图可以看出,每一个RefBase对象包含了一个weakref_impl对象,而weakref_impl对象实现了weakref_type接口,同时它可以包含多个ref_entry对象,前面说过,ref_entry是调试用的一个结构体,实际使用中可以不关注。
提供引用计数器的类RefBase我们就暂时介绍到这里,后面我们再结合智能指针类一起分析,现在先来看看强指针类和弱指针类的定义。强指针类的定义我们在前面介绍轻量级指针的时候已经见到了,就是sp类了,这里就不再把它的代码列出来了。我们来看看它的构造函数的实现:
- template<typenameT>
- sp<T>::sp(T*other)
- :m_ptr(other)
- {
- if(other)other->incStrong(this);
- }
这里传进来的参数other一定是继承于RefBase类的,因此,在函数的内部,它调用的是RefBase类的incStrong函数,它定义在frameworks/base/libs/utils/RefBase.cpp文件中:
- voidRefBase::incStrong(constvoid*id)const
- {
- weakref_impl*constrefs=mRefs;
- refs->addWeakRef(id);
- refs->incWeak(id);
- refs->addStrongRef(id);
- constint32_tc=android_atomic_inc(&refs->mStrong);
- LOG_ASSERT(c>0,"incStrong()calledon%pafterlaststrongref",refs);
- #ifPRINT_REFS
- LOGD("incStrongof%pfrom%p:cnt=%d\n",this,id,c);
- #endif
- if(c!=INITIAL_STRONG_VALUE){
- return;
- }
- android_atomic_add(-INITIAL_STRONG_VALUE,&refs->mStrong);
- const_cast<RefBase*>(this)->onFirstRef();
- }
- RefBase::RefBase()
- :mRefs(newweakref_impl(this))
- {
- //LOGV("Creatingrefs%pwithRefBase%p\n",mRefs,this);
- }
一是增加弱引用计数:
- refs->addWeakRef(id);
- refs->incWeak(id);
- refs->addStrongRef(id);
- constint32_tc=android_atomic_inc(&refs->mStrong);
- if(c!=INITIAL_STRONG_VALUE){
- return;
- }
- android_atomic_add(-INITIAL_STRONG_VALUE,&refs->mStrong);
- const_cast<RefBase*>(this)->onFirstRef();
- #defineINITIAL_STRONG_VALUE(1<<28)
回过头来看弱引用计数是如何增加的,首先是调用weakref_impl类的addWeakRef函数,我们知道,在Release版本中,这个函数也不做,而在Debug版本中,这个函数增加了一个ref_entry对象到了weakref_impl对象的mWeakRefs列表中,表示此weakref_impl对象的弱引用计数被增加了一次。接着又调用了weakref_impl类的incWeak函数,真正增加弱引用计数值就是在这个函数实现的了,weakref_impl类的incWeak函数继承于其父类weakref_type的incWeak函数:
- voidRefBase::weakref_type::incWeak(constvoid*id)
- {
- weakref_impl*constimpl=static_cast<weakref_impl*>(this);
- impl->addWeakRef(id);
- constint32_tc=android_atomic_inc(&impl->mWeak);
- LOG_ASSERT(c>=0,"incWeakcalledon%pafterlastweakref",this);
- }
- constint32_tc=android_atomic_inc(&impl->mWeak);
http://groups.google.com/group/android-platform/browse_thread/thread/cc641db8487dd83
Ah I see. Well the debug code may be broken, though I wouldn't leap to that
conclusion without actually testing it; I know it has been used in the
past. Anyway, these things get compiled out in non-debug builds, so there
is no reason to change them unless you are actually trying to use this debug
code and it isn't working and need to do this to fix it.
既然他也不知道怎么回事,我们也不必深究了,知道有这么回事就行。
这里总结一下强指针类sp在其构造函数里面所做的事情就是分别为目标对象的强引用计数和弱引和计数增加了1。
再来看看强指针类的析构函数的实现:
- template<typenameT>
- sp<T>::~sp()
- {
- if(m_ptr)m_ptr->decStrong(this);
- }
- voidRefBase::decStrong(constvoid*id)const
- {
- weakref_impl*constrefs=mRefs;
- refs->removeStrongRef(id);
- constint32_tc=android_atomic_dec(&refs->mStrong);
- #ifPRINT_REFS
- LOGD("decStrongof%pfrom%p:cnt=%d\n",this,id,c);
- #endif
- LOG_ASSERT(c>=1,"decStrong()calledon%ptoomanytimes",refs);
- if(c==1){
- const_cast<RefBase*>(this)->onLastStrongRef(id);
- if((refs->mFlags&OBJECT_LIFETIME_WEAK)!=OBJECT_LIFETIME_WEAK){
- deletethis;
- }
- }
- refs->removeWeakRef(id);
- refs->decWeak(id);
- }
- constint32_tc=android_atomic_dec(&refs->mStrong);
- if(c==1){
- const_cast<RefBase*>(this)->onLastStrongRef(id);
- if((refs->mFlags&OBJECT_LIFETIME_WEAK)!=OBJECT_LIFETIME_WEAK){
- deletethis;
- }
- }
接下来的ref->removeWeakRef函数调用语句是对应前面在RefBase::incStrong函数里的refs->addWeakRef函数调用语句的,在Release版本中,这也是一个空实现函数,真正实现强引用计数减1的操作下面的refs->decWeak函数,weakref_impl类没有实现自己的decWeak函数,它继承了weakref_type类的decWeak函数:
- voidRefBase::weakref_type::decWeak(constvoid*id)
- {
- weakref_impl*constimpl=static_cast<weakref_impl*>(this);
- impl->removeWeakRef(id);
- constint32_tc=android_atomic_dec(&impl->mWeak);
- LOG_ASSERT(c>=1,"decWeakcalledon%ptoomanytimes",this);
- if(c!=1)return;
- if((impl->mFlags&OBJECT_LIFETIME_WEAK)!=OBJECT_LIFETIME_WEAK){
- if(impl->mStrong==INITIAL_STRONG_VALUE)
- deleteimpl->mBase;
- else{
- //LOGV("Freeingrefs%pofoldRefBase%p\n",this,impl->mBase);
- deleteimpl;
- }
- }else{
- impl->mBase->onLastWeakRef(id);
- if((impl->mFlags&OBJECT_LIFETIME_FOREVER)!=OBJECT_LIFETIME_FOREVER){
- deleteimpl->mBase;
- }
- }
- }
- constint32_tc=android_atomic_dec(&impl->mWeak);
- if((impl->mFlags&OBJECT_LIFETIME_WEAK)!=OBJECT_LIFETIME_WEAK){
- if(impl->mStrong==INITIAL_STRONG_VALUE)
- deleteimpl->mBase;
- else{
- //LOGV("Freeingrefs%pofoldRefBase%p\n",this,impl->mBase);
- deleteimpl;
- }
- }else{
- impl->mBase->onLastWeakRef(id);
- if((impl->mFlags&OBJECT_LIFETIME_FOREVER)!=OBJECT_LIFETIME_FOREVER){
- deleteimpl->mBase;
- }
- }
- if(impl->mStrong==INITIAL_STRONG_VALUE)
- deleteimpl->mBase;
- else{
- //LOGV("Freeingrefs%pofoldRefBase%p\n",this,impl->mBase);
- deleteimpl;
- }
如果是前一种场景,这里的impl->mStrong就必然等于0,而不会等于INITIAL_STRONG_VALUE值,因此,这里就不需要delete目标对象了(impl->mBase),因为前面的RefBase::decStrong函数会负责delete这个对象。这里唯一需要做的就是把weakref_impl对象delete掉,但是,为什么要在这里delete这个weakref_impl对象呢?这里的weakref_impl对象是在RefBase的构造函数里面new出来的,理论上说应该在在RefBase的析构函数里delete掉这个weakref_impl对象的。在RefBase的析构函数里面,的确是会做这件事情:
- RefBase::~RefBase()
- {
- //LOGV("DestroyingRefBase%p(refs%p)\n",this,mRefs);
- if(mRefs->mWeak==0){
- //LOGV("Freeingrefs%pofoldRefBase%p\n",mRefs,this);
- deletemRefs;
- }
- }
但是不要忘记,在这个场景下,目标对象是前面的RefBase::decStrong函数delete掉的,这时候目标对象就会被析构,但是它的弱引用计数值尚未执行减1操作,因此,这里的mRefs->mWeak == 0条件就不成立,于是就不会delete这个weakref_impl对象,因此,就延迟到执行这里decWeak函数时再执行。
如果是后一种情景,这里的impl->mStrong值就等于INITIAL_STRONG_VALUE了,这时候由于没有地方会负责delete目标对象,因此,就需要把目标对象(imp->mBase)delete掉了,否则就会造成内存泄漏。在delete这个目标对象的时候,就会执行RefBase类的析构函数,这时候目标对象的弱引用计数等于0,于是,就会把weakref_impl对象也一起delete掉了。
回到外层的if语句中,如果目标对象的生命周期是受弱引用计数控制的,就执行下面语句:
- impl->mBase->onLastWeakRef(id);
- if((impl->mFlags&OBJECT_LIFETIME_FOREVER)!=OBJECT_LIFETIME_FOREVER){
- deleteimpl->mBase;
- }
理论上说,如果目标对象的生命周期是受弱引用计数控制的,那么当强引用计数和弱引用计数都为0的时候,这时候就应该delete目标对象了,但是这里还有另外一层控制,我们可以设置目标对象的标志值为OBJECT_LIFETIME_FOREVER,即目标对象的生命周期完全不受强引用计数和弱引用计数控制,在这种情况下,即使目标对象的强引用计数和弱引用计数都同时为0,这里也不能delete这个目标对象,那么,由谁来delete掉呢?当然是谁new出来的,就谁来delete掉了,这时候智能指针就完全退化为普通指针了,这里的智能指针设计的非常强大。
分析到这里,有必要小结一下:
A. 如果对象的标志位被设置为0,那么只要发现对象的强引用计数值为0,那就会自动delete掉这个对象;
B. 如果对象的标志位被设置为OBJECT_LIFETIME_WEAK,那么只有当对象的强引用计数和弱引用计数都为0的时候,才会自动delete掉这个对象;
C. 如果对象的标志位被设置为OBJECT_LIFETIME_FOREVER,那么对象就永远不会自动被delete掉,谁new出来的对象谁来delete掉。
到了这里,强指针就分析完成了,最后来分析弱指针。
4. 弱指针
弱指针所使用的引用计数类与强指针一样,都是RefBase类,因此,这里就不再重复介绍了,我们直接来弱指针的实现,它定义在frameworks/base/include/utils/RefBase.h文件中:
- template<typenameT>
- classwp
- {
- public:
- typedeftypenameRefBase::weakref_typeweakref_type;
- inlinewp():m_ptr(0){}
- wp(T*other);
- wp(constwp<T>&other);
- wp(constsp<T>&other);
- template<typenameU>wp(U*other);
- template<typenameU>wp(constsp<U>&other);
- template<typenameU>wp(constwp<U>&other);
- ~wp();
- //Assignment
- wp&operator=(T*other);
- wp&operator=(constwp<T>&other);
- wp&operator=(constsp<T>&other);
- template<typenameU>wp&operator=(U*other);
- template<typenameU>wp&operator=(constwp<U>&other);
- template<typenameU>wp&operator=(constsp<U>&other);
- voidset_object_and_refs(T*other,weakref_type*refs);
- //promotiontosp
- sp<T>promote()const;
- //Reset
- voidclear();
- //Accessors
- inlineweakref_type*get_refs()const{returnm_refs;}
- inlineT*unsafe_get()const{returnm_ptr;}
- //Operators
- COMPARE_WEAK(==)
- COMPARE_WEAK(!=)
- COMPARE_WEAK(>)
- COMPARE_WEAK(<)
- COMPARE_WEAK(<=)
- COMPARE_WEAK(>=)
- inlinebooloperator==(constwp<T>&o)const{
- return(m_ptr==o.m_ptr)&&(m_refs==o.m_refs);
- }
- template<typenameU>
- inlinebooloperator==(constwp<U>&o)const{
- returnm_ptr==o.m_ptr;
- }
- inlinebooloperator>(constwp<T>&o)const{
- return(m_ptr==o.m_ptr)?(m_refs>o.m_refs):(m_ptr>o.m_ptr);
- }
- template<typenameU>
- inlinebooloperator>(constwp<U>&o)const{
- return(m_ptr==o.m_ptr)?(m_refs>o.m_refs):(m_ptr>o.m_ptr);
- }
- inlinebooloperator<(constwp<T>&o)const{
- return(m_ptr==o.m_ptr)?(m_refs<o.m_refs):(m_ptr<o.m_ptr);
- }
- template<typenameU>
- inlinebooloperator<(constwp<U>&o)const{
- return(m_ptr==o.m_ptr)?(m_refs<o.m_refs):(m_ptr<o.m_ptr);
- }
- inlinebooloperator!=(constwp<T>&o)const{returnm_refs!=o.m_refs;}
- template<typenameU>inlinebooloperator!=(constwp<U>&o)const{return!operator==(o);}
- inlinebooloperator<=(constwp<T>&o)const{return!operator>(o);}
- template<typenameU>inlinebooloperator<=(constwp<U>&o)const{return!operator>(o);}
- inlinebooloperator>=(constwp<T>&o)const{return!operator<(o);}
- template<typenameU>inlinebooloperator>=(constwp<U>&o)const{return!operator<(o);}
- private:
- template<typenameY>friendclasssp;
- template<typenameY>friendclasswp;
- T*m_ptr;
- weakref_type*m_refs;
- };
先来看构造函数:
- template<typenameT>
- wp<T>::wp(T*other)
- :m_ptr(other)
- {
- if(other)m_refs=other->createWeak(this);
- }
- RefBase::weakref_type*RefBase::createWeak(constvoid*id)const
- {
- mRefs->incWeak(id);
- returnmRefs;
- }
再来看析构函数:
- template<typenameT>
- wp<T>::~wp()
- {
- if(m_ptr)m_refs->decWeak(this);
- }
分析到这里,弱指针还没介绍完,它最重要的特性我们还没有分析到。前面我们说过,弱指针的最大特点是它不能直接操作目标对象,这是怎么样做到的呢?秘密就在于弱指针类没有重载*和->操作符号,而强指针重载了这两个操作符号。但是,如果我们要操作目标对象,应该怎么办呢,这就要把弱指针升级为强指针了:
- template<typenameT>
- sp<T>wp<T>::promote()const
- {
- returnsp<T>(m_ptr,m_refs);
- }
我们再来看看这个强指针的构造过程:
- template<typenameT>
- sp<T>::sp(T*p,weakref_type*refs)
- :m_ptr((p&&refs->attemptIncStrong(this))?p:0)
- {
- }
- boolRefBase::weakref_type::attemptIncStrong(constvoid*id)
- {
- incWeak(id);
- weakref_impl*constimpl=static_cast<weakref_impl*>(this);
- int32_tcurCount=impl->mStrong;
- LOG_ASSERT(curCount>=0,"attemptIncStrongcalledon%pafterunderflow",
- this);
- while(curCount>0&&curCount!=INITIAL_STRONG_VALUE){
- if(android_atomic_cmpxchg(curCount,curCount+1,&impl->mStrong)==0){
- break;
- }
- curCount=impl->mStrong;
- }
- if(curCount<=0||curCount==INITIAL_STRONG_VALUE){
- boolallow;
- if(curCount==INITIAL_STRONG_VALUE){
- //Attemptingtoacquirefirststrongreference...thisisallowed
- //iftheobjectdoesNOThavealongerlifetime(meaningthe
- //implementationdoesn'tneedtoseethis),oriftheimplementation
- //allowsittohappen.
- allow=(impl->mFlags&OBJECT_LIFETIME_WEAK)!=OBJECT_LIFETIME_WEAK
- ||impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG,id);
- }else{
- //Attemptingtorevivetheobject...thisisallowed
- //iftheobjectDOEShavealongerlifetime(sowecansafely
- //calltheobjectwithonlyaweakref)andtheimplementation
- //allowsittohappen.
- allow=(impl->mFlags&OBJECT_LIFETIME_WEAK)==OBJECT_LIFETIME_WEAK
- &&impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG,id);
- }
- if(!allow){
- decWeak(id);
- returnfalse;
- }
- curCount=android_atomic_inc(&impl->mStrong);
- //Ifthestrongreferencecounthasalreadybeenincrementedby
- //someoneelse,theimplementorofonIncStrongAttempted()isholding
- //anunneededreference.SocallonLastStrongRef()heretoremoveit.
- //(No,thisisnotpretty.)NotethatweMUSTNOTdothisifwe
- //areinfactacquiringthefirstreference.
- if(curCount>0&&curCount<INITIAL_STRONG_VALUE){
- impl->mBase->onLastStrongRef(id);
- }
- }
- impl->addWeakRef(id);
- impl->addStrongRef(id);
- #ifPRINT_REFS
- LOGD("attemptIncStrongof%pfrom%p:cnt=%d\n",this,id,curCount);
- #endif
- if(curCount==INITIAL_STRONG_VALUE){
- android_atomic_add(-INITIAL_STRONG_VALUE,&impl->mStrong);
- impl->mBase->onFirstRef();
- }
- returntrue;
- }
这个函数的作用是试图增加目标对象的强引用计数,但是有可能会失败,失败的原因可能是因为目标对象已经被delete掉了,或者是其它的原因,下面会分析到。前面我们在讨论强指针的时候说到,增加目标对象的强引用计数的同时,也会增加目标对象的弱引用计数,因此,函数在开始的地方首先就是调用incWeak函数来先增加目标对象的引用计数,如果后面试图增加目标对象的强引用计数失败时,会调用decWeak函数来回滚前面的incWeak操作。
这里试图增加目标对象的强引用计数时,分两种情况讨论,一种情况是此时目标对象正在被其它强指针引用,即它的强引用计数大于0,并且不等于INITIAL_STRONG_VALUE,另一种情况是此时目标对象没有被任何强指针引用,即它的强引用计数小于等于0,或者等于INITIAL_STRONG_VALUE。
第一种情况比较简单,因为这时候说明目标对象一定存在,因此,是可以将这个弱指针提升为强指针的,在这种情况下,只要简单地增加目标对象的强引用计数值就行了:
- while(curCount>0&&curCount!=INITIAL_STRONG_VALUE){
- if(android_atomic_cmpxchg(curCount,curCount+1,&impl->mStrong)==0){
- break;
- }
- curCount=impl->mStrong;
- }
- intandroid_atomic_release_cas(int32_toldvalue,int32_tnewvalue,
- volatileint32_t*addr);
- #defineandroid_atomic_cmpxchgandroid_atomic_release_cas
第二种情况比较复杂一点,因为这时候目标对象可能还存在,也可能不存了,这要根据实际情况来判断。如果此时目标对象的强引用计数值等于INITIAL_STRONG_VALUE,说明此目标对象还从未被强指针引用过,这时候弱指针能够被提升为强指针的条件就为:
- allow=(impl->mFlags&OBJECT_LIFETIME_WEAK)!=OBJECT_LIFETIME_WEAK
- ||impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG,id);
即如果目标对象的生命周期只受到强引用计数控制或者在目标对象的具体实现中总是允许这种情况发生。怎么理解呢?如果目标对象的生命周期只受强引用计数控制(它的标志位mFlags为0),而这时目标对象又还未被强指针引用过,它自然就不会被delete掉,因此,这时候可以判断出目标对象是存在的;如果目标对象的生命周期受弱引用计数控制(OBJECT_LIFETIME_WEAK),这时候由于目标对象正在被弱指针引用,因此,弱引用计数一定不为0,目标对象一定存在;如果目标对象的生命周期不受引用计数控制(BJECT_LIFETIME_FOREVER),这时候目标对象也是下在被弱指针引用,因此,目标对象的所有者必须保证这个目标对象还没有被delete掉,否则就会出问题了。在后面两种场景下,因为目标对象的生命周期都是不受强引用计数控制的,而现在又要把弱指针提升为强指针,就需要进一步调用目标对象的onIncStrongAttempted来看看是否允许这种情况发生,这又该怎么理解呢?可以这样理解,目标对象的设计者可能本身就不希望这个对象被强指针引用,只能通过弱指针来引用它,因此,这里它就可以重载其父类的onIncStrongAttempted函数,然后返回false,这样就可以阻止弱指针都被提升为强指针。在RefBase类中,其成员函数onIncStrongAttempted默认是返回true的:
- boolRefBase::onIncStrongAttempted(uint32_tflags,constvoid*id)
- {
- return(flags&FIRST_INC_STRONG)?true:false;
- }
如果此时目标对象的强引用计数值小于等于0,那就说明该对象之前一定被强指针引用过,这时候就必须保证目标对象是被弱引用计数控制的(BJECT_LIFETIME_WEAK),否则的话,目标对象就已经被delete了。同样,这里也要调用一下目标对象的onIncStrongAttempted成员函数,来询问一下目标对象在强引用计数值小于等于0的时候,是否允计将弱指针提升为强指针。下面这个代码段就是执行上面所说的逻辑:
- allow=(impl->mFlags&OBJECT_LIFETIME_WEAK)==OBJECT_LIFETIME_WEAK
- &&impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG,id);
- if(!allow){
- decWeak(id);
- returnfalse;
- }
- curCount=android_atomic_inc(&impl->mStrong);
函数attemptIncStrong的主体逻辑大概就是这样了,比较复杂,读者要细细体会一下。函数的最后,如果此弱指针是允计提升为强指针的,并且此目标对象是第一次被强指针引用,还需要调整一下目标对象的强引用计数值:
- if(curCount==INITIAL_STRONG_VALUE){
- android_atomic_add(-INITIAL_STRONG_VALUE,&impl->mStrong);
- impl->mBase->onFirstRef();
- }
分析到这里,弱指针就介绍完了。强指针和弱指针的关系比较密切,同时它们也比较复杂,下面我们再举一个例子来说明强指针和弱指针的用法,同时也验证一下它们的实现原理。
5. 强指针和弱指针的用法
参考在Ubuntu上为Android系统内置C可执行程序测试Linux内核驱动程序一文,我们在external目录下建立一个C++工程目录weightpointer,它里面有两个文件,一个weightpointer.cpp文件,另外一个是Android.mk文件。
源文件weightpointer.cpp的内容如下:
- #include<stdio.h>
- #include<utils/RefBase.h>
- #defineINITIAL_STRONG_VALUE(1<<28)
- usingnamespaceandroid;
- classWeightClass:publicRefBase
- {
- public:
- voidprintRefCount()
- {
- int32_tstrong=getStrongCount();
- weakref_type*ref=getWeakRefs();
- printf("-----------------------\n");
- printf("StrongRefCount:%d.\n",(strong==INITIAL_STRONG_VALUE?0:strong));
- printf("WeakRefCount:%d.\n",ref->getWeakCount());
- printf("-----------------------\n");
- }
- };
- classStrongClass:publicWeightClass
- {
- public:
- StrongClass()
- {
- printf("ConstructStrongClassObject.\n");
- }
- virtual~StrongClass()
- {
- printf("DestoryStrongClassObject.\n");
- }
- };
- classWeakClass:publicWeightClass
- {
- public:
- WeakClass()
- {
- extendObjectLifetime(OBJECT_LIFETIME_WEAK);
- printf("ConstructWeakClassObject.\n");
- }
- virtual~WeakClass()
- {
- printf("DestoryWeakClassObject.\n");
- }
- };
- classForeverClass:publicWeightClass
- {
- public:
- ForeverClass()
- {
- extendObjectLifetime(OBJECT_LIFETIME_FOREVER);
- printf("ConstructForeverClassObject.\n");
- }
- virtual~ForeverClass()
- {
- printf("DestoryForeverClassObject.\n");
- }
- };
- voidTestStrongClass(StrongClass*pStrongClass)
- {
- wp<StrongClass>wpOut=pStrongClass;
- pStrongClass->printRefCount();
- {
- sp<StrongClass>spInner=pStrongClass;
- pStrongClass->printRefCount();
- }
- sp<StrongClass>spOut=wpOut.promote();
- printf("spOut:%p.\n",spOut.get());
- }
- voidTestWeakClass(WeakClass*pWeakClass)
- {
- wp<WeakClass>wpOut=pWeakClass;
- pWeakClass->printRefCount();
- {
- sp<WeakClass>spInner=pWeakClass;
- pWeakClass->printRefCount();
- }
- pWeakClass->printRefCount();
- sp<WeakClass>spOut=wpOut.promote();
- printf("spOut:%p.\n",spOut.get());
- }
- voidTestForeverClass(ForeverClass*pForeverClass)
- {
- wp<ForeverClass>wpOut=pForeverClass;
- pForeverClass->printRefCount();
- {
- sp<ForeverClass>spInner=pForeverClass;
- pForeverClass->printRefCount();
- }
- }
- intmain(intargc,char**argv)
- {
- printf("TestStrongClass:\n");
- StrongClass*pStrongClass=newStrongClass();
- TestStrongClass(pStrongClass);
- printf("\nTestWeakClass:\n");
- WeakClass*pWeakClass=newWeakClass();
- TestWeakClass(pWeakClass);
- printf("\nTestFroeverClass:\n");
- ForeverClass*pForeverClass=newForeverClass();
- TestForeverClass(pForeverClass);
- pForeverClass->printRefCount();
- deletepForeverClass;
- return0;
- }
在main函数里面,分别实例化了这三个类的对象出来,然后分别传给TestStrongClass函数、TestWeakClass函数和TestForeverClass函数来说明智能指针的用法,我们主要是通过考察它们的强引用计数和弱引用计数来验证智能指针的实现原理。
编译脚本文件Android.mk的内容如下:
- LOCAL_PATH:=$(callmy-dir)
- include$(CLEAR_VARS)
- LOCAL_MODULE_TAGS:=optional
- LOCAL_MODULE:=weightpointer
- LOCAL_SRC_FILES:=weightpointer.cpp
- LOCAL_SHARED_LIBRARIES:=\
- libcutils\
- libutils
- include$(BUILD_EXECUTABLE)
- USER-NAME@MACHINE-NAME:~/Android$mmm./external/weightpointer
- USER-NAME@MACHINE-NAME:~/Android$makesnod
- USER-NAME@MACHINE-NAME:~/Android$adbshell
- root@android:/#cdsystem/bin/
- root@android:/system/bin#./weightpointer
- TestStrongClass:
- ConstructStrongClassObject.
- -----------------------
- StrongRefCount:0.
- WeakRefCount:1.
- -----------------------
- -----------------------
- StrongRefCount:1.
- WeakRefCount:2.
- -----------------------
- DestoryStrongClassObject.
- spOut:0x0.
在TestStrongClass函数里面,首先定义一个弱批针wpOut指向从main函数传进来的StrongClass对象,这时候我们可以看到StrongClass对象的强引用计数和弱引用计数值分别为0和1;接着在一个大括号里面定义一个强指针spInner指向这个StrongClass对象,这时候我们可以看到StrongClass对象的强引用计数和弱引用计数值分别为1和2;当程序跳出了大括号之后,强指针spInner就被析构了,从上面的分析我们知道,强指针spInner析构时,会减少目标对象的强引用计数值,因为前面得到的强引用计数值为1,这里减1后,就变为0了,又由于这个StrongClass对象的生命周期只受强引用计数控制,因此,这个StrongClass对象就被delete了,这一点可以从后面的输出(“Destory StrongClass Object.”)以及试图把弱指针wpOut提升为强指针时得到的对象指针为0x0得到验证。
执行TestWeakClass函数的输出为:
- TestWeakClass:
- ConstructWeakClassObject.
- -----------------------
- StrongRefCount:0.
- WeakRefCount:1.
- -----------------------
- -----------------------
- StrongRefCount:1.
- WeakRefCount:2.
- -----------------------
- -----------------------
- StrongRefCount:0.
- WeakRefCount:1.
- -----------------------
- spOut:0xa528.
- DestoryWeakClassObject.
TestWeakClass函数和TestStrongClass函数的执行过程基本一样,所不同的是当程序跳出大括号之后,虽然这个WeakClass对象的强引用计数值已经为0,但是由于它的生命周期同时受强引用计数和弱引用计数控制,而这时它的弱引用计数值大于0,因此,这个WeakClass对象不会被delete掉,这一点可以从后面试图把弱批针wpOut提升为强指针时得到的对象指针不为0得到验证。
执行TestForeverClass函数的输出来:
- TestFroeverClass:
- ConstructForeverClassObject.
- -----------------------
- StrongRefCount:0.
- WeakRefCount:1.
- -----------------------
- -----------------------
- StrongRefCount:1.
- WeakRefCount:2.
- -----------------------
- -----------------------
- StrongRefCount:0.
- WeakRefCount:0.
- -----------------------
- DestoryForeverClassObject.
这样,从TestStrongClass、TestWeakClass和TestForeverClass这三个函数的输出就可以验证了我们上面对Android系统的强指针和弱指针的实现原理的分析。
至此,Android系统的智能指针(轻量级指针、强指针和弱指针)的实现原理就分析完成了,它实现得很小巧但是很精致,希望读者可以通过实际操作细细体会一下。
转载声明: 本文转自Android系统的智能指针(轻量级指针、强指针和弱指针)的实现原理分析
参考推荐:
老罗的Android之旅(专注于Android底层模块分析,强烈推荐)
相关推荐
不过系统为我们提供了智能指针,避免出现上述问题,本文将系统地分析Android系统智能指针(轻量级指针、强指针和弱指针)的实现原理。在使用C++来编写代码的过程中,指针使用不当造成内存泄漏一般就是因为new了一个...
在计算机系统中,资源是数量有限且对系统正常运行具有一定作用的元素。...不过系统为我们提供了智能指针,避免出现上述问题,本文将系统地分析Android系统智能指针(轻量级指针、强指针和弱指针)的实现原理。
智能指针sp和wp在android c++源码中使用非常频繁,例如IBinder机制,但是它比c++中普通的智能指针要复杂很多,相信不少android学习者如果c++基础不是很扎实的,看起来会比较吃力和枯燥。本人在android 4.2.2源码基础...
下面我们将深入探讨这两种智能指针的工作原理和应用场景。 1. **Strong Pointer(强引用)** - **定义**:强引用是最常见的引用类型,持有对象的强引用意味着该对象不会被垃圾回收器回收,只要强引用存在,对象就...
智能指针的实现原理基于C++的构造函数和析构函数。在对象创建时,智能指针的构造函数会增加目标对象的引用计数;当智能指针被销毁(例如,超出作用域或显式删除),其析构函数会减少目标对象的引用计数。如果引用...
### Android Sensor Framework 原理 #### 一、总体调用关系 Android Sensor Framework 主要由客户端、服务端以及 HAL 层(硬件抽象层)组成。各层之间有着明确的职责分工,使得整个架构能够高效地运行。 ##### ...
在Android系统中,Google实现了一种名为`Sp`(Strong Pointer)的智能指针,它是一个强引用的智能指针,用于确保对象在其生命周期内不会过早被销毁。 智能指针的主要目标是确保对象在不再需要时会被正确地删除,...
总结来说,《Mstar安卓理论及实践篇》不仅是Android开发者关于智能指针的实践手册,更是帮助他们深入理解Android系统内部工作原理的参考书。通过本篇的详细指导,开发者可以更加高效地编写出既稳定又易维护的Android...
【Android智能净水机APP开发(二)】 这篇文章主要探讨了Android智能净水机应用程序的状态页布局和功能实现。作者杨东,来自安徽博约信息科技股份有限公司,详细介绍了如何通过Android编程技术构建一个能够实时反映...
第3章 智能指针 第2篇 Android专用驱动系统 第4章 Logger日志系统 第5章 Binder进程间通信系统 第6章 Ashmem匿名共享内存系统 第7章 Activity组件的启动过程 第8章 Service组件的启动过程 第9章 Android...
让我们深入探讨这两种组件的原理及其在Android开发中的应用。 **AnalogClock(模拟时钟)** AnalogClock组件在Android中用于展示传统的指针式时钟界面,它包括时针、分针和(可选的)秒针。这个组件的设计基于SVG...
9. **内存管理**:理解Chromium如何高效地分配和释放内存,以及如何利用内存池和智能指针来减少内存泄漏,对Android应用开发者来说非常有价值。 10. **UI设计**:Chromium的UI设计遵循Material Design指南,源码中...
第3章 智能指针 3.1 轻量级指针 3.1.1 实现原理分析 3.1.2 应用实例分析 3.2 强指针和弱指针 3.2.1 强指针的实现原理分析 3.2.2 弱指针的实现原理分析 3.2.3 应用实例分析 第2篇 Android专用驱动系统...
在Mstar开发项目中,理解并熟练运用这些智能指针的原理和使用方式,对于正确管理和控制对象生命周期至关重要,能够有效防止内存泄漏和程序崩溃,提高代码的健壮性和可靠性。在实践中,根据项目需求合理选择使用智能...
第3章 智能指针 3.1 轻量级指针 3.1.1 实现原理分析 3.1.2 应用实例分析 3.2 强指针和弱指针 3.2.1 强指针的实现原理分析 3.2.2 弱指针的实现原理分析 3.2.3 应用实例分析 第2篇 Android专用驱动系统 第4章...
TypeHelpers中定义了sp和wp模板,它们是智能指针,用于管理对象生命周期,尤其是在内存敏感的环境中。 - `sp<T>`是一个强引用智能指针,通常用于表示对象的所有权。 - `wp<T>`是一个弱引用智能指针,不保证对象的...