os_unfair_lock #import <os/lock.h>
os_unfair_lock 是用來替代 OSSPinLock 的一個互斥鎖。OSSpinLock 是采用自選忙等待的方式，而 os_unfair_lock 則會刮起等待，可以通過 Debug->Debug Worlflow->Always Show Disassembly 去斷點一個死鎖的 OSSpinLock 是否是循環的執行。
@synchronized
@synchronized 的作用是創建一個遞歸鎖，保證此時沒有其它線程對self對象進行修改，保證代碼的安全性。也就是包裝這段代碼是原子性的，安全的。這個是objective-c的一個鎖定令牌，防止self對象在同一時間內被其他線程訪問，起到保護線程安全的作用。
- 將.m 編譯成.cpp
- 使用view debug overflow
可以看到，@synchronized 的編譯之后的處理 會在在代碼塊前后添加 objc_sync_enter 和 objc_sync_exit方法
添加 symbol breakpoint 找到符號 libobjc.A.dylib`objc_sync_enter
繼續探究一下其源碼
objc_sync_enter
主要時獲取obj對一個的SuncData，然后再對SyncData 里的 recursive_mutex_t 遞歸鎖進行加鎖
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;
int objc_sync_enter(id obj)
{
int result = OBJC_SYNC_SUCCESS;
if (obj) {
// 獲取objc 對應的SyncData 。其中會有一個自旋鎖用來對 代碼塊進行加鎖
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;
}
id2data 的函數時根據obj 對象，以及 ACQUIRE / RELEASE 的標志，獲取對應的SyncData，以及對SyncData 的lockCout 和threadCount 進行處理。
- lockCount 時lock 的次數。最少為0 ， threadCount 則是 0 / 1 。
objc_sync_exit
也是獲取 obj對應的 SyncData（并對lockcount 和threadCount內進行操作，如果threadCount 為0 就不會返回了）。 然后對 SyncData 中的遞歸鎖進行解鎖。
// 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;
}
id2data
id2data 是用來獲取對象對應的SyncData。
- 先從tls 中獲取 緩存， 查找obj對應的數據
- 從cache 中獲取緩存，遍歷查找obj對應的數據，查找，
- 如果找不到，就使用 os_unfair_lock 互斥鎖，加鎖，保證線程安全的去創建新的 SyncData，然后設置
// sDataLists 是一個靜態的全局變量，StripedMap有一個下標算法，根據obj的地址 去獲取下標，然后找到對應的數據
#define LOCK_FOR_OBJ(obj) sDataLists[obj].lock
#define LIST_FOR_OBJ(obj) sDataLists[obj].data
static StripedMap<SyncList> sDataLists;
static SyncData* id2data(id object, enum usage why)
{
// 去 sDataList 查詢 objc 對應的鎖
spinlock_t *lockp = &LOCK_FOR_OBJ(object);
//// 去 sDataList 查詢對應的data 數據，可以看到是一個 SyncData 的二維數組的指針
SyncData **listp = &LIST_FOR_OBJ(object);
SyncData* result = NULL;
// Check per-thread single-entry fast cache for matching object tls 當前的線程
//。
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;
}
}
// 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
// 對threadCount 進行原子操作，-1 只有當lockcount 位0 就全部都解鎖是，晴空threadCout threadCount 最大為1
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.
// 加鎖 使用的 os_unfair_lock 一種自旋鎖 （等待的自旋鎖）
lockp->lock();
{
// 在listp中查找 listp 是多個obj 對應SyncData 的列表數據
SyncData* p;
SyncData* firstUnused = NULL;
for (p = *listp; p != NULL; p = p->nextData) {
if ( p->object == object ) {
//找到listp中存儲的數據，就返回跳轉done
result = p;
// atomic because may collide with concurrent RELEASE
// 對threadCount 進行原子操作，增加1（其實最大就會是1）
OSAtomicIncrement32Barrier(&result->threadCount);
goto done;
}
// 用來找到最后一個 數據被刪除的空間，用來存儲
if ( (firstUnused == NULL) && (p->threadCount == 0) )
firstUnused = p;
}
// no SyncData currently associated with object
// 找不到還去刪除 就會result 位nil， 然后done，會在外面assert 是報錯
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.
// 創建內存，然后設置數據，并加到listp 中 即 sDataLists 中
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;
}
- 有限去查 當前線程的tls中obj對用的SyncData， 找到直接返回（對lockcount/threadCount的操作）
- tls 找不到，再去cache（所有線程的緩存）中查找，找到返回 也對 對lockcount/threadCount 進行操作。 當unlock 且 lockcout == 0 時，會從 tls 中移除數據。 listp 不會移除數據，但是會設置threadCount 為0
- lock是 對 lockcount 進行加1 ，threadcount 不操作， unlock時，lockcount -1 ，如果 lockcount == 0 就將threadcount -1 （原子操作） threadCount 最大是1，最小時0，
- 如果都能查不到，就去加鎖，
- 然后在 listp 中遍歷查詢 （全局變量 sDataLists 的StripedMap 中，Stringp 返回的是多個obj對應的數據（hash沖突的原因，或者說StrpeMap的地址計算邏輯）。同時找是否有空余的內存
- 如果找到數據，就跳轉 8 done （解鎖，然后保存數據到 tls ， 和全局的cache中）
- 如果沒找到，且有空余的內存，就設置數據放到空余的內存地址。然后跳轉 8 done
- 還是沒有就創建 內存，然后設置數據，跳轉 8 done
- done 解鎖，然后保存數據到tls。 cache， 返回查找到的result。 （沒枷鎖卻去解鎖，會返回nil， 不會報錯OBJC_SYNC_NOT_OWNING_THREAD_ERROR）
fetch_cache
根據 _objc_pthread_key key 去線程局部靜態變量查詢數據，根據create 是否在沒有事，自動創建一個
static SyncCache *fetch_cache(bool create)
{
_objc_pthread_data *data;
// 根據 _objc_pthread_key 這個key 獲取，如果沒有且 create = true 就創建一個數據存入
data = _objc_fetch_pthread_data(create);
if (!data) return NULL;
if (!data->syncCache) {
if (!create) {
return NULL;
} else {
int count = 4;
data->syncCache = (SyncCache *)
calloc(1, sizeof(SyncCache) + count*sizeof(SyncCacheItem));
data->syncCache->allocated = count;
}
}
// Make sure there's at least one open slot in the list.
if (data->syncCache->allocated == data->syncCache->used) {
data->syncCache->allocated *= 2;
data->syncCache = (SyncCache *)
realloc(data->syncCache, sizeof(SyncCache)
+ data->syncCache->allocated * sizeof(SyncCacheItem));
}
return data->syncCache;
}
TLS 線程局部存儲
操作系統位線程單獨提供的私有空間，用來將數據與一個正在執行的指定線程關聯起來。 通常只有有限的容量。
進程中的全局變量與函數內定義的靜態(static)變量，是各個線程都可以訪問的共享變量。
如果需要在一個線程內部的各個函數調用都能訪問、但其它線程不能訪問的變量（被稱為static memory local to a thread 線程局部靜態變量），就需要新的機制來實現。這就是TLS。
Linux 中TLS的實現和操作方法
linux:
int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));
int pthread_key_delete(pthread_key_t key);
void *pthread_getspecific(pthread_key_t key);
int pthread_setspecific(pthread_key_t key, const void *value);
獲取線程呢哦的局部靜態變量
static inline void *tls_get_direct(tls_key_t k)
{
ASSERT(is_valid_direct_key(k));
if (_pthread_has_direct_tsd()) {
return _pthread_getspecific_direct(k);
} else {
return pthread_getspecific(k);
}
}
