OC底层探索19-weak和assign区别浅谈

这个问题的答案网上有很多,现在先给出答案。但本文的重点是从底层源码的角度来分析，尤其是对weak的整个源码过程进行分析。

1、 结论

1.1 区别

1.1.1 修饰变量类型的区别

weak 只可以修饰对象。如果修饰基本数据类型，编译器会报错-“Property with ‘weak’ attribute must be of object type”。
assign 可修饰对象，和基本数据类型。当需要修饰对象类型时，MRC时代使用unsafe_unretained。当然，unsafe_unretained也可能产生野指针，所以它名字是"unsafe_”。

1.1.2.是否产生野指针的区别

weak 不会产生野指针问题。因为weak修饰的对象释放后（引用计数器值为0），指针会自动被置nil，之后再向该对象发消息也不会崩溃。 weak是安全的。
assign 如果修饰对象，会产生野指针问题；如果修饰基本数据类型则是安全的。修饰的对象释放后，指针不会自动被置空，此时向对象发消息会崩溃。

1.2 相似

都可以修饰对象类型，但是assign修饰对象会存在问题。

代码使用weak后clang编译后报错，需要使用下方的命令
clang -rewrite-objc -fobjc-arc -stdlib=libc++ -mmacosx-version-min=10.7 -fobjc-runtime=macosx-10.7 -Wno-deprecated-declarations main.m

2、assign原理

@property(nonatomic, assign)int age;

• 通过clang编译之后查看set、get方法，发现本质就是通过地址操作直接对内存进行操作。这一点和strong很像，不同的是strong标记的是对象，是存在引用计数的;
• assign修饰的变量不涉及到引用计数，所以在修饰对象时不安全;

3、weak 原理

id __weak weakObj = obj;
//clang之后
id __attribute__((objc_ownership(weak))) weakObj = obj;

只有在llvm库中找到了objc_ownership，但是没有更多进展了，所以还是从libobjc着手。在代码中增加断点并打开汇编调试。

• 看到对象转weak之后是调用了objc_initWeak.

3.1 涉及到的数据结构

在此之前先了解一下在weak操作中会涉及到的数据结构：StripedMap、SideTable、weak_table_t、weak_entry_t，方便后续的理解.

3.1.1 StripedMap

//StripedMap通过静态变量SideTablesMap进行地址的获取，地址唯一的！！！！
static objc::ExplicitInit<StripedMap<SideTable>> SideTablesMap;
static StripedMap<SideTable>& SideTables() {
    return SideTablesMap.get();
}

class StripedMap {
#if TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR
    enum { StripeCount = 8 };   //真机8个
#else
    enum { StripeCount = 64 };  //模拟器64个
#endif
    struct PaddedT {
        //字节对齐：64字节
        //数组中每一个元素的大小都是64的倍数,因为SideTable占64字节
        T value alignas(CacheLineSize);
    };
    //该类的数据存储方法：array。并且在不同的设备下不同
    PaddedT array[StripeCount];
    //自定义操作符[]
    T& operator[] (const void *p) {
        return array[indexForPointer(p)].value; 
    }
    //通过位运算得出一个不超过当前数组上限的index
    static unsigned int indexForPointer(const void *p) {
        uintptr_t addr = reinterpret_cast<uintptr_t>(p);
        return ((addr >> 4) ^ (addr >> 9)) % StripeCount;
    }
    
    //还有些锁的操作
}

• 通过StripedMap(hash表)封装后完成了内存字节对齐、[]的自定义、还有一些锁的操作；
• <SideTable>通过泛型定义：StripedMap中就是存储n(iPhone设备8、其他64)个SideTable;
• 唯一的StripedMap一对多SideTable;
• 将要转换的对象地址通过位运算处理后放入某个sidetable中,并不是所有对象都存在一个sidetable,提升了查询效率;

3.1.2 SideTable(抽象对象)

struct SideTable {
    spinlock_t slock;
  //引用计数的散列表  
    RefcountMap refcnts;
    //存储数据
    weak_table_t weak_table; 
    //构造函数
    SideTable() {
        memset(&weak_table, 0, sizeof(weak_table));
    }
    //析构函数
    ~SideTable() {
        _objc_fatal("Do not delete SideTable.");
    }
    void lock() { slock.lock(); }
    void unlock() { slock.unlock(); }
    //主要是一些锁操作
};

• 和StripedMap一样，通过封装完成了一些锁方法的添加,而且不用直接暴露weak_table增加稳定性；
• SideTable是hash表的载体，通过SideTable完成了weak_table的操作；
• 唯一的StripedMap一对多SideTable - SideTable一对一weak_table;

3.1.3 weak_table_t （hash表）

struct weak_table_t {
    weak_entry_t *weak_entries; //存储数据
    size_t    num_entries;  // 存储数据的总数
    uintptr_t mask;
    uintptr_t max_hash_displacement;
};

• 唯一的StripedMap一对多SideTable - SideTable一对一weak_table - weak_table一对多weak_entries;

3.1.4 weak_entry_t（存储对象）

#define WEAK_INLINE_COUNT 4
#define REFERRERS_OUT_OF_LINE 2
struct weak_entry_t {
    // 相当于hash表中的key，存储是被weak的目标对象地址
    DisguisedPtr<objc_object> referent;
    union {
        struct {
            // 转换后对象的指针地址
            // 由于存在多次转换，该结构可以看做数组结构
            weak_referrer_t *referrers; //8字节
            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];   //8字节
        };
    };
    bool out_of_line() {
        return (out_of_line_ness == REFERRERS_OUT_OF_LINE);
    }
};

• 唯一的StripedMap一对多SideTable - SideTable一对一weak_table - weak_table一对多weak_entries - weak_entries一对多referrers/inline_referrers;
• 在这里巧妙的使用了一个联合体。
  • 如果一个对象对应的弱引用数目较少的话(<=4)，则其弱引用会被依次保存到一个inline_referrers数组结构里。
  • 如果弱引用多（>4）后，则通过指针平移存储在referrers里，并开始记录总数。会在何时的时机进行扩容。
• 联合体的内存是共用的。默认联合体创建后的第二个8字节位置为0，也就是out_of_line_ness = 0。所以默认会放入inline_referrers这个结构中。

结构图

3.2 storeWeak具体操作

// location是需要weak的对象
// newObjz转换后的对象
static id storeWeak(id *location, objc_object *newObj) {
    Class previouslyInitializedClass = nil;
    id oldObj;
    SideTable *oldTable;
    SideTable *newTable;

 retry:
 //通过haveOld、haveNew完成新增和删除操作
 //haveOld是删除操作
 //haveNew是添加操作
    if (haveOld) {
        // location是weak_entry_t结构，取地址后首地址对应的是referent
        // oldObj = 目标对象-表中的key
        oldObj = *location;
        oldTable = &SideTables()[oldObj];
    } else { oldTable = nil; }
    if (haveNew) {
        newTable = &SideTables()[newObj];
    } else { newTable = nil; }
    //线程安全
    SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable);
    // 删除操作
    if (haveOld) {
        weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
    }
    //新增操作
    if (haveNew) {
        newObj = (objc_object *)
            weak_register_no_lock(&newTable->weak_table, (id)newObj, location, crashIfDeallocating ? CrashIfDeallocating : ReturnNilIfDeallocating);
        *location = (id)newObj;
    }
    //解锁
    SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
    return (id)newObj;
}

• &SideTables()[oldObj];：从StripedMap找到目标hash表sidetable；

3.2.1 oldObj = *location解释

• oldObj就是referent，也就是hash表中的key;

3.2.2 weak_register_no_lock新增

id weak_register_no_lock(weak_table_t *weak_table, id referent_id, 
                      id *referrer_id,..)
{
    // hash表中的key
    objc_object *referent = (objc_object *)referent_id;
    // 要插入的目标对象
    objc_object **referrer = (objc_object **)referrer_id;
    //小对象不处理
    if (referent->isTaggedPointerOrNil()) return referent_id;

    //省略了一些错误处理

    weak_entry_t *entry;
    // 通过referent从hash表中找到weak_entry_t
    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);
    }
    return referent_id;
}

• weak_entry_for_referent通过while循环完成referent的匹配，篇幅原因代码就不放出了；
• 这里出现了append_referrer和weak_entry_insert两个方法。weak_entry_insert相对简单，本次注重分析append_referrer；

3.2.3 append_referrer

static void append_referrer(weak_entry_t *entry, objc_object **new_referrer)
{
    //out_of_line这个方法在上面放出过，判断是否是线性结构储存（referrers）
    if (! entry->out_of_line()) {
        // Try to insert inline.
        // 如果在4个以内有空值
        for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
            if (entry->inline_referrers[i] == nil) {
                entry->inline_referrers[i] = new_referrer;
                return;
            }
        }

        //如果4个放满了，放弃inline_referrers存储，初始化referrers结构
        weak_referrer_t *new_referrers = (weak_referrer_t *)
            calloc(WEAK_INLINE_COUNT, sizeof(weak_referrer_t));
        //通过巡皇的方式完成inline_referrers数组中所有值的复制
        for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
            new_referrers[i] = entry->inline_referrers[i];
        }
        // 状态值的设置，尤其主要out_of_line_ness设置为2，该判断就不会在进入
        entry->referrers = new_referrers;
        entry->num_refs = WEAK_INLINE_COUNT;
        entry->out_of_line_ness = REFERRERS_OUT_OF_LINE;
        entry->mask = WEAK_INLINE_COUNT-1;
        entry->max_hash_displacement = 0;
    }
    // 是否设置线性成功
    ASSERT(entry->out_of_line());
    // 如果超过3/4就进行扩容
    if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) {
        return grow_refs_and_insert(entry, new_referrer);
    }
    size_t begin = w_hash_pointer(new_referrer) & (entry->mask);
    size_t index = begin;
    size_t hash_displacement = 0;
    //找到空的位置后完成赋值
    while (entry->referrers[index] != nil) {
        hash_displacement++;
        index = (index+1) & entry->mask;
        if (index == begin) bad_weak_table(entry);
    }
    weak_referrer_t &ref = entry->referrers[index];
    ref = new_referrer;
    entry->num_refs++;
}

• 就是一些状态参数、指针的操作

4、 weak的使用

转成weak之后完成调用

NSObject *obj1 = [HRTest alloc];
HRTest __weak *weakObj1 = obj1;
[weakObj1 say1];

• 在调用位置打下断点，并且开启汇编

  
  

1. 将obj转为weak；
2. 在调用say1之前，先调用了objc_loadWeakRetained方法;
3. 通过objc_msgSend完成say1消息发送;

4.1 weak之后地址情况

• 即使转weak之后对象的指针地址是不会变化的，而且变量weakObjc1的也是指向objc1。相当于一次浅拷贝，但不涉及引用计数的变化。

4.2 objc_loadWeakRetained

id objc_loadWeakRetained(id *location) {
    id obj;
    id result;
    Class cls;
    SideTable *table;
 retry:
    //和storeWeak中oldvalue逻辑一样，找到key和value
    obj = *location;
    if (obj->isTaggedPointerOrNil()) return obj;
    //找到对应的sidetable表
    table = &SideTables()[obj];
    
    table->lock();
    if (*location != obj) {
        table->unlock();
        goto retry;
    }
    
    result = obj;

    cls = obj->ISA();
    if (! cls->hasCustomRR()) {
        ASSERT(cls->isInitialized());
        if (! obj->rootTryRetain()) {
            result = nil;
        }
    }
    else {
        if (cls->isInitialized() || _thisThreadIsInitializingClass(cls)) {
            BOOL (*tryRetain)(id, SEL) = (BOOL(*)(id, SEL))
                lookUpImpOrForwardTryCache(obj, @selector(retainWeakReference), cls);
            if ((IMP)tryRetain == _objc_msgForward) {
                result = nil;
            }
            else if (! (*tryRetain)(obj, @selector(retainWeakReference))) {
                result = nil;
            }
        }
        else {
            table->unlock();
            class_initialize(cls, obj);
            goto retry;
        }
    }
    table->unlock();
    return result;
}

• 看下来就是发现，该方法就是在方法调用前检查weak对象是否已经被置nil；

3、 销毁

由于weak引用之后不会增加对象的引用计数，所以在对象销毁的时候，weak是如何销毁呢?

// 直接放出和weak销毁有关的步骤
inline void objc_object::clearDeallocating() {
    if (slowpath(!isa.nonpointer)) {
        // Slow path for raw pointer isa.
        sidetable_clearDeallocating();
    }
    ...
}

void objc_object::sidetable_clearDeallocating() {
    SideTable& table = SideTables()[this];
    table.lock();
    RefcountMap::iterator it = table.refcnts.find(this);
    if (it != table.refcnts.end()) {
        if (it->second & SIDE_TABLE_WEAKLY_REFERENCED) {
            weak_clear_no_lock(&table.weak_table, (id)this);
        }
        table.refcnts.erase(it);
    }
    table.unlock();
}

static void weak_entry_remove(weak_table_t *weak_table, weak_entry_t *entry)
{
    // remove entry
    if (entry->out_of_line()) free(entry->referrers);
    bzero(entry, sizeof(*entry));

    weak_table->num_entries--;
    //如果表格大部分是空的，则进行缩容。
    weak_compact_maybe(weak_table);
}

• 释放weak_entry_t对象；
• 并且把side_table中的对象进行clean；