锁

互斥锁 自旋锁 递归锁 条件锁 读写锁

• 互斥锁：pthread_ mutex_t（NSLock基于此封装）每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问对象

objc_sync_enter(self)
执行的代码
objc_sync_exit(self)

类似OC的
@synchronized(self) {
    执行的代码
}

• 自旋锁：os_ unfair_ lock_lock（不会陷入死锁） 等待的过程中是一种whiledo的模式，但对象解锁后能最快的拿到对象，称为效率最高的锁

• 递归锁：NSRecursiveLock 在循环或者递归调用lock时，由于未unlock会导致死锁，此时使用递归，在unlock时会一层层解套（记录递归或者循环的层数让后解）

• 条件锁：NSConditionLock，可自定义条件，但满足条件时进入lock

    let conLock = NSConditionLock.init(condition: 0)
    let queue = DispatchQueue.global()
    //  -------------------- 线程1 --------------------
    queue.async {
      if conLock.tryLock(whenCondition: 0) {
          debugPrint(Thread.current,1)
          conLock.unlock(withCondition: 1)
      }else{
          debugPrint("log1失败")
      }
    }
    //  -------------------- 线程2 --------------------
    queue.async {
      conLock.lock(whenCondition: 3)
      debugPrint(Thread.current,2)
      conLock.unlock(withCondition: 2)
    }
    //  -------------------- 线程3 --------------------
    queue.async {
      conLock.lock(whenCondition: 1)
      debugPrint(Thread.current,3)
      conLock.unlock(withCondition: 3)
    }

        /// 另外一种方式
        let lock = NSConditionLock()
        let queue = DispatchQueue.global()
        queue.async {
            for item in 0...3 {
                lock.lock()
                debugPrint(Thread.current,item)
                sleep(1)
                lock.unlock(withCondition: item)
            }
        }
        
        queue.async {
            lock.lock(whenCondition: 2)
            debugPrint(Thread.current)
            lock.unlock()
        }

• 读写锁：可满足多线程读，写的时候唯一线程所有读的线程也许等待

// 读写锁 pthread_rwlock
    func lock5() {
        let queue = DispatchQueue.global()
        for _ in 0..<5 {
            queue.async { [weak self] in
                self?.readPthreadRWLock()
                self?.writePthreadRWLock()
            }
        }
    }
     
    @objc func readPthreadRWLock() {
        pthread_rwlock_rdlock(&self.rwLock)
        debugPrint(Thread.current,"读文件")
        pthread_rwlock_unlock(&self.rwLock)
    }
    
    @objc func writePthreadRWLock() {
        pthread_rwlock_wrlock(&self.rwLock)
        debugPrint(Thread.current,"写文件")
        sleep(1)
        pthread_rwlock_unlock(&self.rwLock)
    }

atomic为何不能完全保证线程安全

atomic是对属性的set/get方法加锁了，保证了读写的线程安全。但并不能保证属性的线程安全，属性还会有其他的操作（加减、添加、移除等）