Skip to content

Latest commit

 

History

History
220 lines (164 loc) · 10.2 KB

线程同步之@synchronized.md

File metadata and controls

220 lines (164 loc) · 10.2 KB
Raw

mind

这是并发控制方案的系列文章，介绍了各种锁的使用及优缺点。

  1. 自旋锁
  2. os_unfair_lock
  3. 互斥锁
  4. 递归锁
  5. 条件锁
  6. 读写锁
  7. @synchronized

OSSpinLock、os_unfair_lock、pthread_mutex_t、pthread_cond_t、pthread_rwlock_t 是值类型，不是引用类型。这意味着使用 = 会进行复制，使用复制的可能导致闪退。pthread 函数认为其一直处于初始化的内存地址，将其移动到其他内存地址会产生问题。使用copy的OSSpinLock不会崩溃，但会得到一个全新的锁。

如果你对线程、进程、串行、并发、并行、锁等概念还不了解，建议先查看以下文章：

Objective-C 语言提供了创建递归锁的简便方式，即@synchronized指令。@synchronized提供了 recursive lock 提供的功能。例如，阻塞多线程同时访问临界区域，允许同一线程多次加锁访问临界区域。使用@synchronized时，无需创建锁、加锁、解锁，只需为@synchronized传入非空对象，Objective-C 会将其作为锁令牌使用。

1. 如何使用@synchronized

@synchronized使用方法如下：

- (void)myMethod:(id)anObj {
    @synchronized(anObj) {
        // Everything between the braces is protected by the @synchronized directive.
    }
}

传入@synchronized的anObj作为唯一标记符区分临界区域。如果在两个线程同时执行上述方法，传入不同对象，每个线程都会获取锁并执行；如果在两个线程同时执行上述方法，传入同一对象，则一个线程会获取锁，另一个线程被堵塞，直到第一个线程执行完毕。

作为预防措施，@synchronized隐式添加了 exception handler。即使抛出异常，handler 也会释放锁。也就是想要使用@synchronized，必须启用 Objective-C 的 exception。如果不想承受 exception 的开销，可以使用显式锁。

假设添加元素到数组需要实现线程安全：

@interface SynchronizedDemo ()

@property (nonatomic, strong) NSMutableArray *elements;
@property (nonatomic, strong) NSLock *lock;

@end

@implementation SynchronizedDemo

- (instancetype)init
{
    self = [super init];
    if (self) {
        self.elements = [NSMutableArray array];
        self.lock = [[NSLock alloc] init];
    }
    return self;
}

- (void)push:(NSString *)element {
    [self.lock lock];
    
    [self.elements addObject:element];
    
    [self.lock unlock];
}

上述push:方法先加锁、后添加元素，最后解锁。即使多线程同时调用push:方法，数组添加元素的方法同一时间也只会在一个线程执行。

使用@synchronized保护临界区域方法如下：

- (void)push:(NSString *)element {
    @synchronized (self) {
        [self.elements addObject:element];
    }
}

@synchronizedblock效果与[self.lock lock]、[self.lock unlock]一致。可以把self当作NSLock，左大括号标记加锁位置，右大括号标记解锁位置。@synchronized不用担心忘记 unlock。

可以为@synchronized传入任何 Objective-C 对象。因此，在上述示例中可以使用@synchronized(element)代替@synchronized(self)，效果一致。

你可以将前面文章的锁更换为@synchronized，如果遇到问题，可以从文末链接下载源码查看。

2. @synchronized 原理

在@synchronized (self) 添加断点，运行至断点位置选择 Xcode 菜单栏的Debug > Debug Workflow > Always Show Disassembly，可以看到其汇编代码如下：

synchronizedEnterExit

本质上，@synchronized开始结束位置分别调用objc_sync_enter和objc_sync_exit。

Runtime 源码中objc-sync.mm文件包含了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;
}

objc_sync_enter通过传入的对象初始化递归锁。如果参数为nil，@synchronized(nil)调用objc_sync_nil()，最终什么也不执行。

下面是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;

typedef struct {
    SyncData *data;
    unsigned int lockCount;  // number of times THIS THREAD locked this block
} SyncCacheItem;

typedef struct SyncCache {
    unsigned int allocated;
    unsigned int used;
    SyncCacheItem list[0];
} SyncCache;

/*
  Fast cache: two fixed pthread keys store a single SyncCacheItem. 
  This avoids malloc of the SyncCache for threads that only synchronize 
  a single object at a time.
  SYNC_DATA_DIRECT_KEY  == SyncCacheItem.data
  SYNC_COUNT_DIRECT_KEY == SyncCacheItem.lockCount
 */

struct SyncList {
    SyncData *data;
    spinlock_t lock;

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

// 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;

struct SyncData结构体包含@synchronized()传入的参数 object，互斥锁recursive_mutex_t，指向下一个SyncData对象的指针nextData。还包括表示使用当前 block 线程数的threadCount。

struct SyncList包含SyncData和自旋锁spinlock_t，可以将SyncData作为 list 的 node，每个SyncList包含指向链表头的 node，spinlock_t用于阻止多线程并行修改损坏链表数据。由于多数情况下，任一时间只有几个锁在用，而非大量锁，因此该表被实现为链表而非哈希表。为了进一步优化性能，采用了多个链表，根据内存地址将对象映射到不同链表，这样可以减少@synchronized对象间竞争。

当调用objc_sync_enter(obj)时，使用obj的内存地址查找SyncData并加锁，当调用objc_sync_exit时，查找SyncData并解锁。

为避免弱引用的开销，Apple 对锁使用了引用计数。当计数为0时，锁可用于其他对象。使用完毕的锁不会销毁，而是进行复用。

3. @synchronized 性能

Apple 的实现方式智能且快速，但与显式使用锁相比，仍然会不可避免的产生一些额外开销，@synchronized性能也因此相对低一些。特别是以下这几方面：

  • 对象可能被分配到同一个链表，此时仍然会发生竞争。
  • 根据对象查找锁时，需要使用自旋锁加锁、解锁。
  • 在链表查找锁时，需要进行额外工作。
  • 每次加锁、解锁都要按照递归锁进行操作，即使这里不会进行递归。

Demo名称：Synchronization
源码地址：https://github.com/pro648/BasicDemos-iOS/tree/master/Synchronization

上一篇：线程同步之读写锁

参考资料：

  1. More than you want to know about @synchronized
  2. Locks, Thread Safety, and Swift
  3. Let's Build @synchronized
  4. Using the @synchronized Directive