iOS 개발--@synchronized의 원리 분석

개요

iOS 개발에서 잠금 적용은 필수인데, 오늘은 일반적으로 사용되는 @synchronized의 원리에 대해 알아보겠습니다.

목표를 탐색하다

@synchronized를 사용할 때 기본 용도는 다음과 같습니다.

@synchronized (self) {
    // your code here
}

여기 @synchronized에서 매개변수 다음에 코드 블록이 오는 것을 볼 수 있습니다. 이것이 @synchronized기본 사용법입니다. 다음으로 문제를 살펴보겠습니다.

• @synchronized어떤 매개변수를 전달해야 합니까? nil을 통과하면 어떻게 됩니까?
• @synchronized코드 블록은 정확히 무엇입니까?
• @synchronized의 실현 원리는 무엇입니까?
• @synchronized중첩될 수 있는 이유

@synchronized에 대한 예비 탐색

소스 코드에서 @synchronized의 직접적인 구현은 없으며 우리는 이러한 방식으로 기본 구현을 직접 볼 수 없습니다.

파일에 하나 를 main.m구현 @synchronized하고 xcrun으로 방법을 탐색하십시오.

컴파일된 cpp 파일에서 시스템 코드와 함께 @synchronized생성된 코드는 빨간색 박스로 되어 있는데, 보기 좋게 포맷을 맞춰줍니다.

태스크에서 간단히 NSLog 출력을 작성했는데 생성자와 소멸자가 정의된 _SYNC_EXIT 구조가 있고 매개변수를 수신하는 데 사용되는 idtype 도 있음을 확인했습니다.sync_exit

간단한 정보를 제거한 후 기본 프로세스는 다음과 같은 것을 볼 수 있습니다.

• _sync_obj: @synchronized들어오는 매개변수
• 옮기다objc_sync_enter(_sync_obj);
• _sync_exit(_sync_obj): 매개변수를 사용하여 소멸자를 호출하는 것은 실제로 호출하는 것과 동일합니다.objc_sync_exit(_sync_obj);

전체 과정은 복잡하지 않습니다, 우리는 다음에 공부할 것입니다objc_sync_enter(_sync_obj);

인커밍이 있으면 obj업무 obj처리를 하고 , 댓글과 같이 obj있으면 처리 하지 않는다.nil@synchronized(nil) does nothing

동일한 기능 objc_sync_exit(id obj)의 데이터 처리 는 유사합니다.

两个函数都对obj进行了一个id2data()的操作，以及在objc_sync_enter对data进行mutex.lock()和mutex.tryUnlock()操作

SyncData分析

简单分析一下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;

先来看一下核心重点的id2data()源码中主要包含三个部分

#if SUPPORT_DIRECT_THREAD_KEYS
SyncData *data = (SyncData *)tls_get_direct(SYNC_DATA_DIRECT_KEY);
if (data) {......}

这里SUPPORT_DIRECT_THREAD_KEYS用到了tls（Thread Local Storage）线程局部存储，是操作系统为线程单独提供的私有空间，通常只有有限容量。

 SyncCache *cache = fetch_cache(NO);
 if (cache) {......}

在cache中查找，与上一种方式处理逻辑相似，意味着如果支持tls，走第一种方式，如果不支持则走第二种方式。

// 剩余的部分
{......}
done:
......

在LOCK_FOR_OBJ和LIST_FOR_OBJ的宏定义中，有一个sDataList

#define LOCK_FOR_OBJ(obj) sDataLists[obj].lock
#define LIST_FOR_OBJ(obj) sDataLists[obj].data
static StripedMap<SyncList> sDataLists; // 全局哈希表

其中SyncList是一个带有SyncData和lock的结构

struct SyncList {
    SyncData *data;
    spinlock_t lock;
    constexpr SyncList() : data(nil), lock(fork_unsafe_lock) { }
};

sDataList的结构，由于是哈希结构，并不会顺序存储，第一个值不一定实在0位置。

(StripeMap<SyncList>) $0 = {
    array = {
        [0] = {
            value = {
                data = nil
                lock = {
                    mLock = (_os_unfaire_lock_opaque = 0)
                }
            }
        },
        ......
        
        [63] = {
            value = {
                data = nil
                lock = {
                    mLock = (_os_unfaire_lock_opaque = 0)
                }
            }
        },
    }
}

在SyncList中data即为syncData，那么我们在使用@synchronized的嵌套用法时如果参数都是self，将如何存储，所以SyncData使用链表结构，同一个self中的不同操作可以形成链表，通过同一个self找到所有的操作。

解析

static SyncData* id2data(id object, enum usage why)
{
    spinlock_t *lockp = &LOCK_FOR_OBJ(object);
    SyncData **listp = &LIST_FOR_OBJ(object);
    SyncData* result = NULL;

1、如果支持tls走这里，第一次并不存在
7、嵌套的第二层进来的时候，data存在并且支持tls，进入此处的代码
#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;
            8、获取对象被加锁了多少次，如果线程数或锁的数量小于等于零，说明对象不存在
            lockCount = (uintptr_t)tls_get_direct(SYNC_COUNT_DIRECT_KEY);
            if (result->threadCount <= 0  ||  lockCount <= 0) {
                _objc_fatal("id2data fastcache is buggy");
            }
            switch(why) {
            9、如果是ACQUIRE，对象加锁数+1，并进行存储
            case ACQUIRE: {
                lockCount++;
                tls_set_direct(SYNC_COUNT_DIRECT_KEY, (void*)lockCount);
                break;
            }
            10.如果是RELEASE，对象加锁数-1，并进行存储
            case RELEASE:
                lockCount--;
                tls_set_direct(SYNC_COUNT_DIRECT_KEY, (void*)lockCount);
                11、锁为零，对result中的线程数
                if (lockCount == 0) {
                    // remove from fast cache
                    tls_set_direct(SYNC_DATA_DIRECT_KEY, NULL);
                    // atomic because may collide with concurrent ACQUIRE
                    11、线程数-1，这里也说明@synchronized是跨线程的，多线程的
                    OSAtomicDecrement32Barrier(&result->threadCount);
                }
                break;
            case CHECK:
                // do nothing
                break;
            }

            return result;
        }
    }
#endif

2、如果不持之走这里，第一次进来并不存在cache
    // 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();

3、第一次过来list为空，why = ACQUIRE，所以也不走这里
    {
        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
                12、如果是同一个对象
                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;
        }
    }
4、第一次走这里，创建一个新的SyncData并加入到list
    // 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);
    5、用头插法进行数据排列
    result->nextData = *listp;
    *listp = result;
    
    6、对syncData进行存储
 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;
}

syncData的操作有mutex.lock()，多层嵌套会对相同的参数连续加锁，这也是@synchronized的重要特性之一，

总结

• @synchronized调用时生成了一张哈希表sDataList，其中维护了一个存放SyncList的array结构

• @synchronized通过objc_sync_enter和objc_sync_exit对数据进行加锁和解锁的操作，其中用到的是递归锁

• 其中生成的SyncData有两种存储方式：tls，cache

• 可重入：通过lockcount对对象进行加锁次数的管理，可多次加锁

• 多线程：通过threadcount维护多线程对对象加锁的情况

• @synchronized传入的参数应该保证：生命周期大于多线程要操作的数据源，通常传入self（vc)也是因为在创建syncData链时，创建一条即可。