iOS底层探索-@synchronized

晓之卫
197 阅读7分钟

上篇 锁 的探索中我们了解了常规锁的一些内容，但开发中最便捷的还是@synchronized，它 既是互斥锁又是递归锁，因此我们单独拉出一个篇章

1、查看转译文件

我们准备一个简单的 @synchronized 使用，然后使用 clang -rewrite-objc ViewController.m命令将ViewController.m文件转译成.cpp文件 image.png 在.cpp文件中我们找到我们写入@synchronized的方法viewDidLoad：

static void _I_ViewController_viewDidLoad(ViewController * self, SEL _cmd) {
    ((void (*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){(id)self, (id)class_getSuperclass(objc_getClass("ViewController"))}, sel_registerName("viewDidLoad"));

    NSObject *obj = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc"));
    
    // @synchronized 在cpp中被转换为try catch
    { id _rethrow = 0; id _sync_obj = (id)obj; objc_sync_enter(_sync_obj);
try {
    // 构造与析构时执行指定方法
    struct _SYNC_EXIT { _SYNC_EXIT(id arg) : sync_exit(arg) {}
    ~_SYNC_EXIT() {objc_sync_exit(sync_exit);}
    id sync_exit;
    } _sync_exit(_sync_obj);

    } catch (id e) {_rethrow = e;}
{ struct _FIN { _FIN(id reth) : rethrow(reth) {}
    ~_FIN() { if (rethrow) objc_exception_throw(rethrow); }
    id rethrow;
    } _fin_force_rethow(_rethrow);}
}
  • @synchronized 在cpp中被转换为 try catch，我们主要关注try中的内容；之前探索分类时我们知道，_SYNC_EXIT() 与 ~_SYNC_EXIT()这种组合写法表示构造与析构时会执行括号中指定的方法
  • objc_sync_enter() 与 objc_sync_exit()是我们探索的重点

2、底层探索

2.1、objc_sync_enter() 与 objc_sync_exit()

// Begin synchronizing on 'obj'. 
// Allocates recursive mutex associated with 'obj' if needed.
// Returns OBJC_SYNC_SUCCESS once lock is acquired.  
int objc_sync_enter(id obj)
{
    int result = OBJC_SYNC_SUCCESS;

    if (obj) {
        SyncData* data = id2data(obj, ACQUIRE);
        ASSERT(data);
        data->mutex.lock();
    } else {
        // @synchronized(nil) does nothing
        if (DebugNilSync) {
            _objc_inform("NIL SYNC DEBUG: @synchronized(nil); set a breakpoint on objc_sync_nil to debug");
        }
        objc_sync_nil();
    }

    return result;
}

// End synchronizing on 'obj'. 
// Returns OBJC_SYNC_SUCCESS or OBJC_SYNC_NOT_OWNING_THREAD_ERROR
int objc_sync_exit(id obj)
{
    int result = OBJC_SYNC_SUCCESS;

    if (obj) {
        SyncData* data = id2data(obj, RELEASE); 
        if (!data) {
            result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;
        } else {
            bool okay = data->mutex.tryUnlock();
            if (!okay) {
                result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;
            }
        }
    } else {
        // @synchronized(nil) does nothing
    }

    return result;
}
  • 源码可以看到，如果@synchronized中未传入内容，则锁失效
  • 通过id2data()函数，可以得到SyncData类型数据，然后这个类型中有加锁和解锁方法

2.2、SyncData

typedef struct alignas(CacheLineSize) SyncData {
    struct SyncData* nextData;
    DisguisedPtr<objc_object> object;
    int32_t threadCount;  // number of THREADS using this block
    recursive_mutex_t mutex;
} SyncData;
  • 从结构我们能看出，SyncData是一个链表
  • threadCount ：记录了有多少条线程使用了这个block
  • mutex ：是一把 recursive_mutex_t 类型的递归锁
  • object ：在前边 探索分类与关联对象 中我们知道DisguisedPtr是对object的封装（将传入的任意类型进行格式统一）

2.3、id2data(obj, ACQUIRE)

static SyncData* id2data(id object, enum usage why)
{
    // 获取锁
    spinlock_t *lockp = &LOCK_FOR_OBJ(object);
    // 指向链表指针的指针即头结点
    SyncData **listp = &LIST_FOR_OBJ(object);
    // 最终用于返回的接收者
    SyncData* result = NULL;

#if SUPPORT_DIRECT_THREAD_KEYS
    // Check per-thread single-entry fast cache for matching object
    bool fastCacheOccupied = NO;
    SyncData *data = (SyncData *)tls_get_direct(SYNC_DATA_DIRECT_KEY);
    if (data) {
        fastCacheOccupied = YES;

        if (data->object == object) {
            // Found a match in fast cache.
            uintptr_t lockCount;

            result = data;
            lockCount = (uintptr_t)tls_get_direct(SYNC_COUNT_DIRECT_KEY);
            if (result->threadCount <= 0  ||  lockCount <= 0) {
                _objc_fatal("id2data fastcache is buggy");
            }

            switch(why) {
            case ACQUIRE: {
                lockCount++;
                tls_set_direct(SYNC_COUNT_DIRECT_KEY, (void*)lockCount);
                break;
            }
            case RELEASE:
                lockCount--;
                tls_set_direct(SYNC_COUNT_DIRECT_KEY, (void*)lockCount);
                if (lockCount == 0) {
                    // remove from fast cache
                    tls_set_direct(SYNC_DATA_DIRECT_KEY, NULL);
                    // atomic because may collide with concurrent ACQUIRE
                    OSAtomicDecrement32Barrier(&result->threadCount);
                }
                break;
            case CHECK:
                // do nothing
                break;
            }

            return result;
        }
    }
#endif

    // Check per-thread cache of already-owned locks for matching object
    SyncCache *cache = fetch_cache(NO);
    if (cache) {
        unsigned int i;
        for (i = 0; i < cache->used; i++) {
            SyncCacheItem *item = &cache->list[i];
            if (item->data->object != object) continue;

            // Found a match.
            result = item->data;
            if (result->threadCount <= 0  ||  item->lockCount <= 0) {
                _objc_fatal("id2data cache is buggy");
            }

            switch(why) {
            case ACQUIRE:
                item->lockCount++;
                break;
            case RELEASE:
                item->lockCount--;
                if (item->lockCount == 0) {
                    // remove from per-thread cache
                    cache->list[i] = cache->list[--cache->used];
                    // atomic because may collide with concurrent ACQUIRE
                    OSAtomicDecrement32Barrier(&result->threadCount);
                }
                break;
            case CHECK:
                // do nothing
                break;
            }

            return result;
        }
    }

    // Thread cache didn't find anything.
    // Walk in-use list looking for matching object
    // Spinlock prevents multiple threads from creating multiple 
    // locks for the same new object.
    // We could keep the nodes in some hash table if we find that there are
    // more than 20 or so distinct locks active, but we don't do that now.

    lockp->lock();

    {
        SyncData* p;
        SyncData* firstUnused = NULL;
        for (p = *listp; p != NULL; p = p->nextData) {
            if ( p->object == object ) {
                result = p;
                // atomic because may collide with concurrent RELEASE
                OSAtomicIncrement32Barrier(&result->threadCount);
                goto done;
            }
            if ( (firstUnused == NULL) && (p->threadCount == 0) )
                firstUnused = p;
        }

        // no SyncData currently associated with object
        if ( (why == RELEASE) || (why == CHECK) )
            goto done;

        // an unused one was found, use it
        if ( firstUnused != NULL ) {
            result = firstUnused;
            result->object = (objc_object *)object;
            result->threadCount = 1;
            goto done;
        }
    }

    // Allocate a new SyncData and add to list.
    // XXX allocating memory with a global lock held is bad practice,
    // might be worth releasing the lock, allocating, and searching again.
    // But since we never free these guys we won't be stuck in allocation very often.
    posix_memalign((void **)&result, alignof(SyncData), sizeof(SyncData));
    result->object = (objc_object *)object;
    result->threadCount = 1;
    new (&result->mutex) recursive_mutex_t(fork_unsafe_lock);
    result->nextData = *listp;
    *listp = result;

 done:
    lockp->unlock();
    if (result) {
        // Only new ACQUIRE should get here.
        // All RELEASE and CHECK and recursive ACQUIRE are 
        // handled by the per-thread caches above.
        if (why == RELEASE) {
            // Probably some thread is incorrectly exiting 
            // while the object is held by another thread.
            return nil;
        }
        if (why != ACQUIRE) _objc_fatal("id2data is buggy");
        if (result->object != object) _objc_fatal("id2data is buggy");

#if SUPPORT_DIRECT_THREAD_KEYS
        if (!fastCacheOccupied) {
            // Save in fast thread cache
            tls_set_direct(SYNC_DATA_DIRECT_KEY, result);
            tls_set_direct(SYNC_COUNT_DIRECT_KEY, (void*)1);
        } else 
#endif
        {
            // Save in thread cache
            if (!cache) cache = fetch_cache(YES);
            cache->list[cache->used].data = result;
            cache->list[cache->used].lockCount = 1;
            cache->used++;
        }
    }

    return result;
}

// Use multiple parallel lists to decrease contention among unrelated objects.
#define LOCK_FOR_OBJ(obj) sDataLists[obj].lock
#define LIST_FOR_OBJ(obj) sDataLists[obj].data
static StripedMap<SyncList> sDataLists;
  • id2data() 函数中主要分为1个准备模块和4个逻辑模块
2.3.1、预备模块
static SyncData* id2data(id object, enum usage why)
{
    // 获取锁
    spinlock_t *lockp = &LOCK_FOR_OBJ(object);
    // 指向链表指针的指针即头结点
    SyncData **listp = &LIST_FOR_OBJ(object);
    // 最终用于返回的接收者
    SyncData* result = NULL;
    
    ......
}

  • SyncList

    struct SyncList {
    SyncData *data;
    // 包含 spinlock 锁
    spinlock_t lock;

    constexpr SyncList() : data(nil), lock(fork_unsafe_lock) { }
};

  • 全局Hash表StripedMap

    //缓存带spinlock锁能力的类或结构体

// StripedMap<T> is a map of void* -> T, sized appropriately 
// for cache-friendly lock striping. 
// For example, this may be used as StripedMap<spinlock_t>
// or as StripedMap<SomeStruct> where SomeStruct stores a spin lock.
template<typename T>
class StripedMap {
#if TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR
    enum { StripeCount = 8 };
#else
    enum { StripeCount = 64 };
#endif
    ......
}

    • 如果将所有锁对象放入同一张表中，那么在用这个对象时需要其他对象解锁，因此更好的方法是每个对象创建一张表，但如果无节制的创建表会造成大量内存开销，因此苹果采取折中方式使用 StripeCount 写死能创建的表数量，真机为8张、模拟器为64张

    • 因为真机只有8张@synchronized对象缓存表、模拟器有64张@synchronized对象缓存表，所以常规未使用大量不同@synchronized对象时，从8张表中取数据效率肯定比64张高，所以这就是为什么@synchronized锁在真机中效率更高一些的原因

2.3.2、查找快速缓存
static SyncData* id2data(id object, enum usage why)
{
    ......
    
    #if SUPPORT_DIRECT_THREAD_KEYS
    // Check per-thread single-entry fast cache for matching object
    bool fastCacheOccupied = NO;
    SyncData *data = (SyncData *)tls_get_direct(SYNC_DATA_DIRECT_KEY);
    if (data) {
        // 快速缓存中查到则置为YES
        fastCacheOccupied = YES;

        if (data->object == object) {
            // Found a match in fast cache.
            uintptr_t lockCount;

            result = data;
            lockCount = (uintptr_t)tls_get_direct(SYNC_COUNT_DIRECT_KEY);
            if (result->threadCount <= 0  ||  lockCount <= 0) {
                _objc_fatal("id2data fastcache is buggy");
            }

            switch(why) {
            case ACQUIRE: {
                lockCount++;
                tls_set_direct(SYNC_COUNT_DIRECT_KEY, (void*)lockCount);
                break;
            }
            case RELEASE:
                lockCount--;
                tls_set_direct(SYNC_COUNT_DIRECT_KEY, (void*)lockCount);
                if (lockCount == 0) {
                    // remove from fast cache
                    tls_set_direct(SYNC_DATA_DIRECT_KEY, NULL);
                    // atomic because may collide with concurrent ACQUIRE
                    OSAtomicDecrement32Barrier(&result->threadCount);
                }
                break;
            case CHECK:
                // do nothing
                break;
            }

            return result;
        }
    }
#endif
    ......
}
  • 通过 SYNC_DATA_DIRECT_KEY 标志位快速查找 SyncData
2.3.3、查找缓存cache
static SyncData* id2data(id object, enum usage why)
{
    ......
    
    // TLS -- 线程的局部存储空间
    // Check per-thread cache of already-owned locks for matching object
    
    // _objc_pthread_data --> syncCache
    SyncCache *cache = fetch_cache(NO);
    if (cache) {
        unsigned int i;
        for (i = 0; i < cache->used; i++) {
            SyncCacheItem *item = &cache->list[i];
            if (item->data->object != object) continue;

            // Found a match.
            // 缓存中匹配到了SyncData,则赋值给用于返回的result
            result = item->data;
            if (result->threadCount <= 0  ||  item->lockCount <= 0) {
                _objc_fatal("id2data cache is buggy");
            }

            // 根据传入的加锁、解锁类型对线程的引用计数进行加减
            switch(why) {
            case ACQUIRE:
                item->lockCount++;
                break;
            case RELEASE:
                item->lockCount--;
                if (item->lockCount == 0) {
                    // remove from per-thread cache
                    cache->list[i] = cache->list[--cache->used];
                    // atomic because may collide with concurrent ACQUIRE
                    // 当线程中对block的引用减为0后,将线程的计数-1
                    OSAtomicDecrement32Barrier(&result->threadCount);
                }
                break;
            case CHECK:
                // do nothing
                break;
            }

            return result;
        }
    }
    
    ......
}
  • TLS ：每条线程都有一小块专门存放该线程信息的局部存储空间
  • fetch_cache() --> _objc_pthread_data --> syncCache(系统专门备注：// for @synchronize)
  • syncCacheItem 
    typedef struct {
    SyncData *data;
    unsigned int lockCount;  // number of times THIS THREAD locked this block
} SyncCacheItem;
    • lockCount：当前线程对block加了几次锁（因为可能递归加锁）
2.3.4、查找全局Hash表StripedMap

前两个模块是在 当前线程的TLS中找SyncData，如果都没找到则到 全局Hash表StripedMap 中去找

static SyncData* id2data(id object, enum usage why)
{
    ......
    
    // Thread cache didn't find anything.
    // Walk in-use list looking for matching object
    // Spinlock prevents multiple threads from creating multiple 
    // locks for the same new object.
    // We could keep the nodes in some hash table if we find that there are
    // more than 20 or so distinct locks active, but we don't do that now.

    lockp->lock();

    {
        SyncData* p;
        SyncData* firstUnused = NULL;
        // 查找链表下一节点
        for (p = *listp; p != NULL; p = p->nextData) {
            if ( p->object == object ) {
                // 链表中找到
                result = p;
                // atomic because may collide with concurrent RELEASE
                // 当前线程是第一次加锁,线程数+1
                OSAtomicIncrement32Barrier(&result->threadCount);
                goto done;
            }
            if ( (firstUnused == NULL) && (p->threadCount == 0) )
                firstUnused = p;
        }

        // no SyncData currently associated with object
        if ( (why == RELEASE) || (why == CHECK) )
            goto done;

        // an unused one was found, use it
        if ( firstUnused != NULL ) {
            result = firstUnused;
            result->object = (objc_object *)object;
            result->threadCount = 1;
            goto done;
        }
    }
    
    ......
}
  • 当在链表中找到 SyncData 后，goto done，进入 done 方法，将找到的 SyncData 存入 快速缓存 与 缓存 中
2.3.5、初次加锁

缓存 和 全局Hash表StripedMap 中都找不到那么就是初次加锁了，这里对参数进行一些初始化操作，并new一个 recursive_mutex_t 递归锁

static SyncData* id2data(id object, enum usage why)
{
    ......
    
    // Allocate a new SyncData and add to list.
    // XXX allocating memory with a global lock held is bad practice,
    // might be worth releasing the lock, allocating, and searching again.
    // But since we never free these guys we won't be stuck in allocation very often.
    posix_memalign((void **)&result, alignof(SyncData), sizeof(SyncData));
    result->object = (objc_object *)object;
    result->threadCount = 1;
    new (&result->mutex) recursive_mutex_t(fork_unsafe_lock);
    result->nextData = *listp;
    *listp = result;
    
    ......
}

小结

  • 缓存中查找流程：fetch_cache() --> _objc_pthread_data --> syncCache(系统专门备注：// for @synchronize) --> syncCacheItem --> SyncData

  • SyncData 为每一个 @synchronized 的参数object 分配了一把递归锁并记录有几个线程使用了block

  • @synchronized 的底层主要是找 链表SyncData，流程是：先找线程TSL中的快速缓存，再找TSL中的缓存，再找 全局Hash表StripedMap(系统分配的8或64张表)，都找不到则进行初始化

  • threadCount 与 lockCount的区别 ：

    • threadCount ：记录的是有多少条线程加锁了block
    • lockCount ：记录的是单独一条线程加锁了多少次block（递归加锁在同一线程，但加了多次的锁） image.png
avatar
文章
阅读
粉丝