iOS中锁的分析：多种锁、源码和读写锁

IOS

2023-09-04 15:26:41

引言

在多线程编程中，锁是至关重要的同步机制，它确保在并发访问共享资源时数据的完整性和线程安全性。iOS提供了多种锁机制，每种都有其独特的特性和适用场景。本文将深入剖析iOS中各种锁，包括互斥锁、读写锁，以及通过源码分析解读它们的实现原理。

一、锁的分类

iOS中的锁可分为以下两大类：

1. 互斥锁

互斥锁保证在任何时刻只有一个线程可以访问临界区（共享资源的访问区域）。互斥锁有两大特性：

互斥性： 仅允许一个线程进入临界区。
同步性： 线程在进入临界区之前必须先获取锁，在退出临界区后必须释放锁。

2. 读写锁

读写锁允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。读写锁也有两种特性：

读写互斥性： 不允许写入线程同时访问临界区，而允许多个读取线程同时访问临界区。
写入互斥性： 不允许多个写入线程同时访问临界区，即保证写入操作的原子性。

二、互斥锁

1. 原理

互斥锁通过一个私有布尔变量（_isLocked）来记录当前锁的状态。当线程请求获取锁时，会先检查_isLocked，如果为true，则等待，直到_isLocked变为false再获取锁。获取锁后，线程将_isLocked设置为true，确保其他线程无法再获取锁。

2. 使用场景

互斥锁适用于需要严格保证线程安全性，且写入操作较多的场景。例如：

保护共享数据结构，如哈希表、链表。
同步对共享资源的访问，如文件操作、数据库读写。

三、读写锁

1. 原理

读写锁通过两个私有变量（_readCount和_writeCount）来记录当前锁的状态：

_readCount记录当前正在读取共享资源的线程数量。
_writeCount记录当前正在写入共享资源的线程数量。

读写锁的获取规则如下：

读锁获取： 当_writeCount为0时，可以获取读锁。
写锁获取： 当_readCount和_writeCount都为0时，可以获取写锁。

2. 使用场景

读写锁适用于读操作远多于写操作的场景。例如：

保护缓存数据，允许多个线程同时读取缓存，但只允许一个线程更新缓存。
同步对数据库表的访问，允许多个线程同时查询表，但只允许一个线程修改表。

四、源码分析

1. 互斥锁（NSLock）

class NSLock {
    private var _isLocked = false
    
    func lock() {
        while _isLocked {
            Thread.yield()
        }
        _isLocked = true
    }
    
    func unlock() {
        _isLocked = false
    }
}

2. 读写锁（NSReadWriteLock）

class NSReadWriteLock {
    private var _readCount = 0
    private var _writeCount = 0
    private var _readLock = os_unfair_lock()
    private var _writeLock = os_unfair_lock()
    
    func readLock() {
        os_unfair_lock_lock(_readLock)
        _readCount += 1
        os_unfair_lock_unlock(_readLock)
    }
    
    func readUnlock() {
        os_unfair_lock_lock(_readLock)
        _readCount -= 1
        os_unfair_lock_unlock(_readLock)
    }
    
    func writeLock() {
        os_unfair_lock_lock(_writeLock)
        while _readCount > 0 || _writeCount > 0 {
            os_unfair_lock_unlock(_writeLock)
            Thread.yield()
            os_unfair_lock_lock(_writeLock)
        }
        _writeCount += 1
        os_unfair_lock_unlock(_writeLock)
    }
    
    func writeUnlock() {
        os_unfair_lock_lock(_writeLock)
        _writeCount -= 1
        os_unfair_lock_unlock(_writeLock)
    }
}