信号量

经测试swift3
测试版本xcode 8.3.2 iOS 10.1.1 iPhone6p
还是存在这个弱点

let lock = DispatchSemaphore(value: 1)//信号量创建，1表示最多可以进入的线程数，当参数为1的时候可以当同步锁使用
lock.wait()//上锁
//dosometing
lock.signal()//开锁

###自旋锁
>```  
var lock = OS_SPINLOCK_INIT //创建参数
OSSpinLockLock(&lock) //上锁
//dosomething
OSSpinLockUnlock(&lock)//开锁

场景设置：三个高中低的并发线程，优先级高的线程抢占CPU的能力总是高于优先级低的线程（不是说低优先级的线程就不能运行了，这个就不说了，自己揣摩）。

如果上面的场景成立了,那么低优先级的线程就会持有锁，但是不能抢占cpu资源，从而导致任务迟迟不能完成，无法释放锁，造成cpu（大量占用cpu）堵塞做许多无用功。。。貌似如此一说，同步锁都会有这臭毛病了，但是呢，，实践才是检验真理的唯一标准

创建三个并发队列：

        let bq1 = DispatchQueue(label: "1", qos: DispatchQoS.utility, attributes: DispatchQueue.Attributes.concurrent)
        let bq2 = DispatchQueue(label: "2", qos: DispatchQoS.default, attributes: DispatchQueue.Attributes.concurrent)
        let bq3 = DispatchQueue(label: "3", qos: DispatchQoS.userInteractive, attributes: DispatchQueue.Attributes.concurrent)
//优先级关系bq3>bq2>bq1

先测试自旋锁

       var lock = OS_SPINLOCK_INIT
        
        
        bq1.async {
            OSSpinLockLock(&lock)
            for i in 0 ..< 1000 {
                sleep(1)
                print("低级\(i)")
            }
            OSSpinLockUnlock(&lock)
            
        }
        sleep(1)
        bq2.async {
            OSSpinLockLock(&lock)
            for i in 0 ..< 1000 {
                sleep(1)
                print("中级\(i)")
            }
            OSSpinLockUnlock(&lock)
            
        }
        sleep(1)
        bq3.async {
            OSSpinLockLock(&lock)
            for i in 0 ..< 1000 {
                sleep(1)
                print("高级\(i)")
            }
            OSSpinLockUnlock(&lock)
            
        }

结果：

查看cup占有@2x.png

再来看看我们的主角信号量

 let lock = DispatchSemaphore(value: 1)
        
        
        bq1.async {
            lock.wait()
            for i in 0 ..< 1000 {
                sleep(1)
                print("低级\(i)")
            }
            lock.signal()
            
        }
        sleep(1)
        bq2.async {
             lock.wait()
            for i in 0 ..< 1000 {
                sleep(1)
                print("中级\(i)")
            }
            lock.signal()
            
        }
        sleep(1)
        bq3.async {
             lock.wait()
            for i in 0 ..< 1000 {
                sleep(1)
                print("高级\(i)")
            }
            lock.signal()
            
        }

Q19@2x.png

总结：果断抛弃自旋锁，投入信号量的怀抱吧