在Objective-C中如何@synchronized锁定/解锁？

@synchronized是否不使用“锁定”和“解锁”来实现互斥？那么它如何锁定/解锁？

以下程序的输出仅是“ Hello World”。

@interface MyLock: NSLock<NSLocking>
@end

@implementation MyLock

- (id)init {
    return [super init];
}

- (void)lock {
    NSLog(@"before lock");
    [super lock];
    NSLog(@"after lock");
}

- (void)unlock {
    NSLog(@"before unlock");
    [super unlock];
    NSLog(@"after unlock");
}

@end


int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

    MyLock *lock = [[MyLock new] autorelease];
    @synchronized(lock) {
        NSLog(@"Hello World");
    }

    [pool drain];
}

就像这样，Objective-C语言级同步使用互斥量NSLock。从语义上讲，存在一些小的技术差异，但是将它们视为在一个共同的（更原始的）实体之上实现的两个单独的接口，基本上是正确的。

特别是对于a，NSLock您具有显式锁，而对于与@synchronized您要同步的对象相关联的隐式锁。语言级别锁定的好处是编译器可以理解它，因此它可以处理范围界定问题，但是从机械上讲，它们的行为基本上相同。

您可以将其@synchronized视为编译器重写：

- (NSString *)myString {
  @synchronized(self) {
    return [[myString retain] autorelease];
  }
}

转换为：

- (NSString *)myString {
  NSString *retval = nil;
  pthread_mutex_t *self_mutex = LOOK_UP_MUTEX(self);
  pthread_mutex_lock(self_mutex);
  retval = [[myString retain] autorelease];
  pthread_mutex_unlock(self_mutex);
  return retval;
}

这并不完全正确，因为实际转换更加复杂并且使用了递归锁，但是应该可以理解这一点。

在Objective-C中，@synchronized块自动为您处理锁定和解锁（以及可能的异常）。运行时实质上会动态生成一个NSRecursiveLock，该对象与您正在同步的对象相关联。此Apple文档对此进行了更详细的说明。这就是为什么您看不到NSLock子类的日志消息的原因-同步的对象可以是任何东西，而不仅仅是NSLock。

基本上，这@synchronized (...)是一种简化代码的便捷构造。像大多数简化的抽象一样，它也具有相关的开销（将其视为隐藏的成本），意识到这一点很好，但是无论如何使用这种结构时，原始性能可能并不是最高的目标。

其实

{
  @synchronized(self) {
    return [[myString retain] autorelease];
  }
}

直接转换为：

// needs #import <objc/objc-sync.h>
{
  objc_sync_enter(self)
    id retVal = [[myString retain] autorelease];
  objc_sync_exit(self);
  return retVal;
}

此API自iOS 2.0起可用，并使用...导入。

#import <objc/objc-sync.h>

Apple的@synchronized实现是开源的，可以在这里找到。Mike ash就此主题写了两篇非常有趣的文章：

• 锁，线程安全和Swift
• 让我们构建@synchronized

简而言之，它具有一个表，该表将对象指针（使用其内存地址作为键）映射到pthread_mutex_t锁，这些锁将根据需要进行锁定和解锁。

它只是将信号量与每个对象相关联，并使用它。