一文理解Android系统中强指针的实现

强指针和弱指针基础

android中的智能指针包括：轻量级指针、强指针、弱指针。
强指针：它主要是通过强引用计数来进行维护对象的生命周期。
弱指针：它主要是通过弱引用计数来进行维护所指向对象的生命周期。
如果在一个类中使用了强指针或者弱指针的技术，那么这个类就必须从refbase这个类进行做继承，因为强指针和弱指针是通过refbase这个类来提供实现的引用计数器。
强指针和弱指针关系相对于轻量级指针来说更加亲密，因此他们一般是相互配合使用的。

强指针原理分析

以下针对源码的分析都是来源于android5.0系统源码
强指针的定义实现主要在\frameworks\rs\cpp\util\refbase.h文件中

class refbase
{
public:
            //定义了成员变量用于维护强引用对象的引用计数
            void            incstrong(const void* id) const;
            //定义了成员变量用于维护强引用对象的引用计数
            void            decstrong(const void* id) const;
          
            void            forceincstrong(const void* id) const;

            //获取强指针计数的数量.
            int32_t         getstrongcount() const;
    //这个类主要实现计数器的
    class weakref_type
    {
    public:
        refbase*            refbase() const;

        void                incweak(const void* id);
        void                decweak(const void* id);

        // acquires a strong reference if there is already one.
        bool                attemptincstrong(const void* id);

        // acquires a weak reference if there is already one.
        // this is not always safe. see processstate.cpp and bpbinder.cpp
        // for proper use.
        bool                attemptincweak(const void* id);

        //! debugging only: get current weak ref count.
        int32_t             getweakcount() const;

        //! debugging only: print references held on object.
        void                printrefs() const;

        //! debugging only: enable tracking for this object.
        // enable -- enable/disable tracking
        // retain -- when tracking is enable, if true, then we save a stack trace
        //           for each reference and dereference; when retain == false, we
        //           match up references and dereferences and keep only the
        //           outstanding ones.

        void                trackme(bool enable, bool retain);
    };

            weakref_type*   createweak(const void* id) const;

            weakref_type*   getweakrefs() const;

            //! debugging only: print references held on object.
    inline  void            printrefs() const { getweakrefs()->printrefs(); }

            //! debugging only: enable tracking of object.
    inline  void            trackme(bool enable, bool retain)
    {
        getweakrefs()->trackme(enable, retain);
    }

    typedef refbase basetype;

protected:
                            refbase();
    virtual                 ~refbase();

    //! flags for extendobjectlifetime()
    enum {
        object_lifetime_strong  = 0x0000,
        object_lifetime_weak    = 0x0001,
        object_lifetime_mask    = 0x0001
    };

            void            extendobjectlifetime(int32_t mode);

    //! flags for onincstrongattempted()
    enum {
        first_inc_strong = 0x0001
    };

    virtual void            onfirstref();
    virtual void            onlaststrongref(const void* id);
    virtual bool            onincstrongattempted(uint32_t flags, const void* id);
    virtual void            onlastweakref(const void* id);

private:
    friend class referencemover;
    static void movereferences(void* d, void const* s, size_t n,
            const referenceconverterbase& caster);

private:
    friend class weakref_type;
    //通过类对象来获取计数器数据。
    class weakref_impl;

                            refbase(const refbase& o);
            refbase&        operator=(const refbase& o);

        weakref_impl* const mrefs;
};

通过以上类定义可以看到 refbase类里面嵌套着weakref_type类，这个weakref_type类也的对象mrefs来描述对象的引用计数。也就是说每一个refbase对象都包含一个weakref_type对象。
virtual表示的是虚函数，friend表示友元函数，

总结

如果一个对象的生命周期控制标志值被设置为0的情况下，只要它的强引用计数值也为0，那么系统就会自动释放这个对象。

到此这篇关于一文理解android系统中强指针的实现的文章就介绍到这了,更多相关android 强指针内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！