队列的创建和获取：

    // 串行队列
    let serialQueue = DispatchQueue(label: "www.google.com")
    
    // 并行队列
    let concurrentQueue = DispatchQueue(label: "www.google.com1", attributes: .concurrent)
    
    // 主队列
    let mainQueue = DispatchQueue.main
    
    // 全局并发队列
    let globalQueue = DispatchQueue.global()
    
    // 指定队列优先级
    let con = DispatchQueue(label: "conQueue", qos: .userInitiated)

    // 串行队列、同步执行    ---->> 在当前线程顺序执行
    func serialQueueSync() {
        print("begin")
        for i in 0...8 {
            serialQueue.sync {
                print(i, Thread.current)
            }
        }
        print("end")
    }
    
    // 串行队列、异步执行   ---->> 在新线程顺序执行
    func serialQueueAsync() {
        print("begin")
        for i in 0...8 {
            serialQueue.async {
                print(i, Thread.current)
            }
        }
        print("end")
    }
    
    // 并行队列、同步执行    ---->> 在当前线程顺序执行
    func concurrentQueueSync() {
        print("begin")
        for i in 0...180 {
            concurrentQueue.sync {
                print(i, Thread.current)
            }
        }
        print("end")
    }
    
    // 并行队列、异步执行    ---->> 在新线程乱序执行
    func concurrentQueueAsync() {
        print("begin")
        for i in 0...8 {
            concurrentQueue.async {
                print(i)
            }
        }
        print("end")
    }

    // 延时执行
    func queueDelay() {
        
        print(Date())
        Thread.sleep(forTimeInterval: 2)
        print(Date())
        // 延迟执行
        mainQueue.asyncAfter(deadline: .now() + 2) {
            print(Date())
            print(Thread.current)
        }
        print(Date())
    }

    // 线程间通讯
    func communicateBetweenQueue() {
        
        globalQueue.async {
            let a = "a" // 假设为延时操作，比如下载图片
            print(Thread.current)
            self.mainQueue.async {
                print(a, Thread.current)
            }
        }
    }

    // 线程安全
    func threadSafty() {
        var names = ["li"]
        
        for i in 0...10 {
            concurrentQueue.async {
                // 加锁 同OC @synchronized(self) {}
                objc_sync_enter(self)
                names.append("\(i)")
                print(names)
                objc_sync_exit(self)
            }
        }
        // 或利用阻塞式的特点
        for x in 11...20 {
            concurrentQueue.async(flags: .barrier, execute: {
                names.append("\(x)")
                print(names)
            })
        }
    }

// 阻塞式队列
    func barrier() {
        
        print("begin")
        for i in 40...60 {
            concurrentQueue.async {
                if i == 40 {
                    Thread.sleep(forTimeInterval: 1)
                }
                print(i)
            }
        }
        concurrentQueue.async(flags: .barrier) {
            print("barrier1", Thread.current)
        }
        for i in 30...39 {
            concurrentQueue.async {
                print(i)
            }
        }
        concurrentQueue.async(flags: .barrier) {
            print("barrier2", Thread.current)
        }
        for i in 0...29 {
            concurrentQueue.async {
                print(i)
            }
        }
        print("end")
    }

    // 信号量
    func dispatchSemaphore() {

        let semaphore = DispatchSemaphore(value: 1)
        concurrentQueue.async {
            _ = semaphore.wait(timeout: .distantFuture)
            print(1, Date())
            sleep(1)
            semaphore.signal()
        }

        concurrentQueue.async {
            _ = semaphore.wait(timeout: .distantFuture)
            print(2, Date())
            sleep(2)
            semaphore.signal()
        }
        
        concurrentQueue.async {
            _ = semaphore.wait(timeout: .distantFuture)
            print(3, Date())
            sleep(3)
            semaphore.signal()
        }
        print("semaphore")
    }

    // 队列组
    func dispatchGroup() {
        
        // 队列组
        let group = DispatchGroup()
        
        group.enter()
        concurrentQueue.async {
            sleep(1)
            print(1)
            group.leave()
        }
        
        group.enter()
        concurrentQueue.async {
    //      sleep(2)
            print(2)
            group.leave()
        }
        
        group.notify(queue: mainQueue) {
            print(3)
        }
    }

• 如何设计一个线程安全的字典或数组？

在编码过程中，对数组进行多线程写入，会引起崩溃:

var names = ["li"]
for i in 0...10 {
    concurrentQueue.async {
        names.append("\(i)")
        print(names)
    }
}

采用部分代码加锁可解决这一问题：

var names = ["li"]
for i in 0...10 {
    concurrentQueue.async {
        // 加锁 同OC @synchronized(self) {}
        objc_sync_enter(self)
        names.append("\(i)")
        print(names)
        objc_sync_exit(self)
    }
}

在实践操作中，对数组进行多线程的读取并不会引起崩溃

var names = ["li", "wang", "sun", "zhao", "qiao", "zhang", "gai", "tu", "yi", "fei", "huo"]
for a in 0...10 {
    concurrentQueue.async {
        print(a, names[a])
    }
}

如何设计一个线程安全的字典或数组

实验证明多线程的读取数组或字典是不会引起崩溃的

多线程的写入字典或数组会引起崩溃

1. 读取时保证没有别的线程在写
2. 写入时保证没有别的线程在写或读
   当满足上面两个要求时可实现线程安全的字典或数组

• 利用阻塞式的特点，我们将所有的写入操作写入阻塞式操作中，即可满足条件