Bagaimana cara @synchronized mengunci / membuka kunci di Objective-C?

Apakah @synchronized tidak menggunakan "kunci" dan "membuka" untuk mencapai pengecualian bersama? Bagaimana cara mengunci / membuka kunci?

Output dari program berikut ini hanya "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];
}

Sinkronisasi tingkat bahasa Objective-C menggunakan mutex, seperti NSLockhalnya. Semantik ada beberapa perbedaan teknis kecil, tetapi pada dasarnya benar untuk menganggap mereka sebagai dua antarmuka terpisah yang diimplementasikan di atas entitas umum (lebih primitif).

Khususnya dengan NSLockAnda memiliki kunci eksplisit sedangkan dengan @synchronizedAnda memiliki kunci implisit yang terkait dengan objek yang Anda gunakan untuk menyinkronkan. Manfaat dari penguncian tingkat bahasa adalah kompiler memahaminya sehingga dapat menangani masalah pelingkupan, tetapi pada dasarnya mereka berperilaku sama.

Anda dapat menganggapnya @synchronizedsebagai penulisan ulang kompiler:

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

ditransformasikan menjadi:

- (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;
}

Itu tidak sepenuhnya benar karena transformasi yang sebenarnya lebih kompleks dan menggunakan kunci rekursif, tetapi harus mendapatkan titik di seberang.

Di Objective-C, sebuah @synchronizedblok menangani penguncian dan pembukaan kunci (serta kemungkinan pengecualian) secara otomatis untuk Anda. Runtime secara dinamis pada dasarnya menghasilkan NSRecursiveLock yang dikaitkan dengan objek yang Anda sinkronkan. Dokumentasi Apple ini menjelaskannya secara lebih rinci. Inilah sebabnya mengapa Anda tidak melihat pesan log dari subkelas NSLock Anda - objek yang Anda sinkronkan bisa apa saja, bukan hanya NSLock.

Pada dasarnya, @synchronized (...)adalah konstruk kenyamanan yang merampingkan kode Anda. Seperti kebanyakan abstraksi yang menyederhanakan, abstraksi ini menghubungkan overhead (menganggapnya sebagai biaya tersembunyi), dan ada baiknya untuk mengetahui hal itu, tetapi kinerja mentah mungkin bukan tujuan tertinggi ketika menggunakan konstruksi tersebut.

Sebenarnya

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

mentransformasikan langsung menjadi:

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

API ini tersedia sejak iOS 2.0 dan diimpor menggunakan ...

#import <objc/objc-sync.h>

Implementasi @synchronized dari Apple adalah open source dan dapat ditemukan di sini . Mike ash menulis dua posting yang sangat menarik tentang subjek ini:

• Kunci, Keamanan Thread, dan Swift
• Ayo Bangun @sinkronisasi

Singkatnya ia memiliki tabel yang memetakan pointer objek (menggunakan alamat memori mereka sebagai kunci) untuk pthread_mutex_tmengunci, yang dikunci dan dibuka kunci sesuai kebutuhan.

Itu hanya mengaitkan semaphore dengan setiap objek, dan menggunakannya.