Objective-C weak

苹果开源代码

weak 弱引用，不持有对象，对象的引用计数不增加; 当对象相互持有时，造成循环引用，导致内存泄漏，weak打破相互持有，防止内存泄漏。

用作修饰属性和__weak关键字

使用：

delegate:

@property (nonatomic, weak) id <xxxDelegate> delegate;

block:

@property (nonatomic, copy) void (^blcok)(void);


__weak typeof(self) weakSelf = self;
self.blcok = ^{
    //weakSelf
};

weak是怎么实现的呢？

原理是,把弱引用指针和该指针所指向的对象关联起来保存到一个hash表中管理，对象dealloc时清空该对象关联的弱引用。

首先看下对象生命周期，创建->使用->释放，从这三个过程展开

通过在苹果开源代码中objc-weak.h和objc-weak.m

弱引用创建 

• objc_initWeak 创建

/** 
 * @return storeWeak方法返回的是newObj
 * @param location __weak 指针地址
 * @param newObj 指针指向的对象地址
 * 健壮性判断和 三个bool类型 具体在 storeWeak中介绍
 * 不是线程安全的
 */
id
objc_initWeak(id *location, id newObj)
{
    if (!newObj) {
        *location = nil;
        return nil;
    }

    return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
        (location, (objc_object*)newObj);
}

 

• objc_storeWeak 保存

载查看保存过程首先要先了解以下内容

haveOld: 当前weak指针是否指向对象，true 指向对象，这个对象需要被释放，这个对象可能是nil; false就是没有指向对象

haveNew: 是否分配新的值，true会被分配新的值；false不会被分配。

DontCrashIfDeallocating: true: newObject已经被释放或者newObject不支持弱引用；false用nil替代存储

SideTable

struct SideTable {
    spinlock_t slock; //自旋锁 
    RefcountMap refcnts;//引用计数hash表
    weak_table_t weak_table; //内部包含弱引用hash表
    ...
};

每个对象都有一个SideTable，sideTable是存储在StripedMap中，stripedMap是一个静态的。

weak_table_t

struct weak_table_t {
    weak_entry_t *weak_entries;
    size_t    num_entries; //表的容量 每次扩大2倍 默认64
    uintptr_t mask; //mask 默认是size_t-1 规范hash变量的范围在[0 - (size-1)]中；使用 w_hash_pointer(new_referrer) & (entry->mask)
    uintptr_t max_hash_displacement; //最大偏移量
};

以对象的地址为指针，weak_entry_t的结构体为value保存 ，weak_entry_t 是保存weak对象的hash表(已obj地址为key)。这里的hash表解决冲突使用的是开放定址法。

weak_entry_t

struct weak_entry_t {
    DisguisedPtr<objc_object> referent;
    union {
        struct {
            weak_referrer_t *referrers;
            uintptr_t        out_of_line_ness : 2;
            uintptr_t        num_refs : PTR_MINUS_2; //容量
            uintptr_t        mask;//
            uintptr_t        max_hash_displacement;
        };
        struct {
            // out_of_line_ness field is low bits of inline_referrers[1]
            weak_referrer_t  inline_referrers[WEAK_INLINE_COUNT];
        };
    };
    .....
};

 DisguisedPtr<objc_object> 对对象的封装，为了隐藏一些信息，不被外部查看(包括通过内存工具)

union中

 out_of_line_ness 判断标示为如果 out_of_line_ness == 0b10 使用 union中 referrers 就是上面的；否则使用inline_referrers；

inline_referrers size为4；对象对应的弱引用指针个数小于等于4使用inline_referrers，大于4使用referrers。ps(inline_referrers是一个数组，按顺序排列, 不用对弱引用指针地址进行hash算法;referrers是hash表通过开放定址法解决冲突)

num_refs 指针容量最小为8

mask: num_refs-1 做&运算保证对对象地址hash后范围在[0-mask)

max_hash_displacement: 最大偏移量，解决hash冲突时最大偏移量，没有hash冲突为0

out_of_line_ness: 这个标示为什么会是2呢，不清楚。

总结下上面的结构：

SideTable中包含有结构体weak_table_t,weak_table_t中含有hash表weak_entries，weak_entries是以object的地址为key，value是weak_entry_t，weak_entry_t中包含weak_referrer_t，用来存放weak的指针

• weak_unregister_no_lock

void
weak_unregister_no_lock(weak_table_t *weak_table, id referent_id, 
                        id *referrer_id)
{
    //旧对象
    objc_object *referent = (objc_object *)referent_id;
    //弱引用指针
    objc_object **referrer = (objc_object **)referrer_id;

    weak_entry_t *entry;

    if (!referent) return;
    // weak_table weak_table_t. entry weak_entry_t
    if ((entry = weak_entry_for_referent(weak_table, referent))) {
        //移除 referrer
        remove_referrer(entry, referrer);
        //判断指向对象的weak指针是否还有
        bool empty = true;
        //weak指针两个不同的存放方式
        if (entry->out_of_line()  &&  entry->num_refs != 0) {
            empty = false;
        }
        else {
            for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
                if (entry->inline_referrers[i]) {
                    empty = false; 
                    break;
                }
            }
        }
        //没有 一处entry
        if (empty) {
            weak_entry_remove(weak_table, entry);
        }
    }
    // referrer 在objc_storeWeak()中还有用所以不能置空
    // Do not set *referrer = nil. objc_storeWeak() requires that the 
    // value not change.
}

weak_unregister_no_lock 功能是删除对象所对应的weak 指针，删除后再判断对象是否还有

•  weak_register_no_lock

id 
weak_register_no_lock(weak_table_t *weak_table, id referent_id, 
                      id *referrer_id, bool crashIfDeallocating)
{
    //new obj
    objc_object *referent = (objc_object *)referent_id;
    //弱引用指针
    objc_object **referrer = (objc_object **)referrer_id;
    //isTaggedPointer 是不会被释放的，所以不用处理
    if (!referent  ||  referent->isTaggedPointer()) return referent_id;

    // ensure that the referenced object is viable
    //确定 new obj是存在的
    bool deallocating;
    if (!referent->ISA()->hasCustomRR()) {
        deallocating = referent->rootIsDeallocating();
    }
    else {
        BOOL (*allowsWeakReference)(objc_object *, SEL) = 
            (BOOL(*)(objc_object *, SEL))
            object_getMethodImplementation((id)referent, 
                                           SEL_allowsWeakReference);
        if ((IMP)allowsWeakReference == _objc_msgForward) {
            return nil;
        }
        deallocating =
            ! (*allowsWeakReference)(referent, SEL_allowsWeakReference);
    }

    if (deallocating) {
        if (crashIfDeallocating) {
            _objc_fatal("Cannot form weak reference to instance (%p) of "
                        "class %s. It is possible that this object was "
                        "over-released, or is in the process of deallocation.",
                        (void*)referent, object_getClassName((id)referent));
        } else {
            return nil;
        }
    }

    // now remember it and where it is being stored
    weak_entry_t *entry;
    //是否在weak_table 已经存在该对象entry
    if ((entry = weak_entry_for_referent(weak_table, referent))) {
        //有就新增
        append_referrer(entry, referrer);
    } 
    else {
        //新建
        weak_entry_t new_entry(referent, referrer);
        weak_grow_maybe(weak_table);
        weak_entry_insert(weak_table, &new_entry);
    }

    // Do not set *referrer. objc_storeWeak() requires that the 
    // value not change.

    return referent_id;
}

weak_register_no_lock 功能是向对象关联weak指针；(ps:TaggedPointer是一个特殊类型，使用很小空间的对象(所使用的size小于等于指针的size)；例如NSString的长度小于9为使就是TaggedPointer类型,相当于把对象存放在指针里面，并且不会释放)。

/** 
 * @return storeWeak方法返回的是newObj
 * @param location __weak 指针地址
 * @param newObj 指针指向的对象地址
 */
OBJC_EXPORT id _Nullable
objc_storeWeak(id _Nullable * _Nonnull location, id _Nullable obj) 
    OBJC_AVAILABLE(10.7, 5.0, 9.0, 1.0, 2.0);

objc_storeWeak具体实现
enum CrashIfDeallocating {
    DontCrashIfDeallocating = false, DoCrashIfDeallocating = true
};
template <HaveOld haveOld, HaveNew haveNew,
          CrashIfDeallocating crashIfDeallocating>
static id 
storeWeak(id *location, objc_object *newObj)
{
    assert(haveOld  ||  haveNew);
    if (!haveNew) assert(newObj == nil);

    Class previouslyInitializedClass = nil;
    //保存就对象
    id oldObj;
    //SideTable含有成员变量 weak_table_t(保存weak指针的hash表)
    SideTable *oldTable;
    SideTable *newTable;

    // Acquire locks for old and new values.
    // Order by lock address to prevent lock ordering problems. 
    // Retry if the old value changes underneath us.
 retry:
    if (haveOld) {
        //把当前weak指针指向的对象放到oldObj
        oldObj = *location;
        //获取oldObj所对应的SideTable
        oldTable = &SideTables()[oldObj];
    } else {
        oldTable = nil;
    }
    if (haveNew) {
        //获取oldObj所对应的SideTable
        newTable = &SideTables()[newObj];
    } else {
        newTable = nil;
    }
    
    //加锁
    SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable);
    // 判断是否在多线程下被修改
    if (haveOld  &&  *location != oldObj) {
        SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
        goto retry;
    }

    // Prevent a deadlock between the weak reference machinery
    // and the +initialize machinery by ensuring that no 
    // weakly-referenced object has an un-+initialized isa.
    if (haveNew  &&  newObj) {
        Class cls = newObj->getIsa();
        //判断cls非空并且已经+initialized(initialized class第一次实例化前调用)
        if (cls != previouslyInitializedClass  &&  
            !((objc_class *)cls)->isInitialized()) 
        {
            SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
            _class_initialize(_class_getNonMetaClass(cls, (id)newObj));

            // If this class is finished with +initialize then we're good.
            // If this class is still running +initialize on this thread 
            // (i.e. +initialize called storeWeak on an instance of itself)
            // then we may proceed but it will appear initializing and 
            // not yet initialized to the check above.
            // Instead set previouslyInitializedClass to recognize it on retry.
            previouslyInitializedClass = cls;

            goto retry;
        }
    }

    // Clean up old value, if any.
    //清除就职
    if (haveOld) {
        weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
    }

    // Assign new value, if any.
    //分配新值
    if (haveNew) {
        //如果注册失败返回nil
        newObj = (objc_object *)
            weak_register_no_lock(&newTable->weak_table, (id)newObj, location, 
                                  crashIfDeallocating);
        // weak_register_no_lock returns nil if weak store should be rejected
    
        // Set is-weakly-referenced bit in refcount table.
        // 在引用计数表中设置弱引用位
        if (newObj  &&  !newObj->isTaggedPointer()) {
            newObj->setWeaklyReferenced_nolock();
        }

        // Do not set *location anywhere else. That would introduce a race.
        //weak指针指向对象
        *location = (id)newObj;
    }
    else {
        //无新值 不设置
        // No new value. The storage is not changed.
    }
    
    //解锁
    SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
    //返回
    return (id)newObj;
}

总结流程:

释放

weak_clear_no_lock

void 
weak_clear_no_lock(weak_table_t *weak_table, id referent_id) 
{
    //dealloc的对象
    objc_object *referent = (objc_object *)referent_id;
    //查找对象对用的entry
    weak_entry_t *entry = weak_entry_for_referent(weak_table, referent);
    if (entry == nil) {
        /// XXX shouldn't happen, but does with mismatched CF/objc
        //printf("XXX no entry for clear deallocating %p\n", referent);
        return;
    }

    // zero out references
    weak_referrer_t *referrers;
    size_t count;
    //根据 out_of_line判断使用的是数组/hash表
    if (entry->out_of_line()) {
        referrers = entry->referrers;
        count = TABLE_SIZE(entry);
    } 
    else {
        referrers = entry->inline_referrers;
        count = WEAK_INLINE_COUNT;
    }
    
    //循环把weak指针置空
    for (size_t i = 0; i < count; ++i) {
        objc_object **referrer = referrers[i];
        if (referrer) {
            if (*referrer == referent) {
                *referrer = nil;
            }
            else if (*referrer) {
                _objc_inform("__weak variable at %p holds %p instead of %p. "
                             "This is probably incorrect use of "
                             "objc_storeWeak() and objc_loadWeak(). "
                             "Break on objc_weak_error to debug.\n", 
                             referrer, (void*)*referrer, (void*)referent);
                objc_weak_error();
            }
        }
    }
    //删除 entry
    weak_entry_remove(weak_table, entry);
}

以上是基本过程，有些方法没有说到,使一些hash表的操作，有兴趣的朋友，可以下载源码自己查看。

SideTable的整体图解形式如下:(图画的不太标准)