gcd小结

//: Playground - noun: a place where people can play

import UIKit
import Dispatch

//MARK: - DispatchQueue

// 初始化一个默认队列
let lab = "com.dispatch"
// 线程的优先级 quality of service
let qos = DispatchQoS.default
// attributes 队列的属性
let attr = DispatchQueue.Attributes.concurrent
// 自动释放频率
let autorelease = DispatchQueue.AutoreleaseFrequency.never
// 队列
let queue = DispatchQueue.init(label: lab, qos: qos, attributes: attr, autoreleaseFrequency: autorelease, target: nil)

// MARK: - 队列分类

// 主队列(对应主线程)
let mainQueue = DispatchQueue.main
// 全局队列
let globalQueue = DispatchQueue.global()
// 优先级队列
let globalQos = DispatchQueue.global(qos: DispatchQoS.QoSClass.background)

// MARK: - 任务分类
// 串行
let serialQueue = DispatchQueue(label: "com.leo.serialQueue")
// 异步
serialQueue.async {

}
// 同步
serialQueue.sync {

}
// 并行
let concurrentQueue = DispatchQueue(label: "com.leo.concurrentQueue",attributes:.concurrent)
// 异步
concurrentQueue.async {

}
// MARK: - 任务对象
let item = DispatchWorkItem {

}
let item2 = DispatchWorkItem.init(qos: qos, flags: DispatchWorkItemFlags.enforceQoS) {

}
DispatchQueue.global().async(execute: item)

// MARK: - after（延迟执行)
let deadline = DispatchTime.now() + 2.0
DispatchQueue.global().asyncAfter(deadline: deadline) {

}
let timer = DispatchSource.makeTimerSource()
timer.setEventHandler {

}
timer.setCancelHandler {

}
// 1秒后执行，然后10秒后自动取消，允许10毫秒的误差
timer.schedule(deadline: .now(), repeating: 2, leeway: .microseconds(10))
//timer.schedule(deadline: .now() + .seconds(1), interval: 2.0, leeway: .microseconds(10))
timer.resume()
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 10) {
    timer.cancel()
}

// MARK: - DispatchGroup

func test(id:Int,ok:@escaping ()->()) {

    print("id",id)
    ok()
}
let group = DispatchGroup()
group.enter()
test(id: 0) {
    group.leave()
}
group.enter()
test(id: 1) {
    group.leave()
}
group.wait(timeout:.now() + 3)

item.notify(queue: queue) {
    print("item end")
}
queue.async(group: group, execute: item)
queue.async(group: group, execute: item2)


group.notify(queue: DispatchQueue.main, work: DispatchWorkItem.init(block: {
    print("All network is done")
}))

// MARK: - 信号量 Semaphore
let semaphore = DispatchSemaphore.init(value: 2)
let queue3 = DispatchQueue.init(label: "com.semaphore", qos: .default, attributes: .concurrent, autoreleaseFrequency: .never, target: nil)
queue3.async {
    semaphore.wait()
    // doSomething
    test(id: 1, ok: {
        semaphore.signal()
    })
}
queue3.async {
    semaphore.wait()
    // doSomething
    test(id: 2, ok: {
        semaphore.signal()
    })
}
queue3.async {
    semaphore.wait()
    // doSomething
    test(id: 3, ok: {
        semaphore.signal()
    })
}
// Barrier 屏障 线程锁
let concurrentQueueBarr = DispatchQueue.init(label: "com.lab.barr")
concurrentQueueBarr.async {
    // doSomething
}
concurrentQueueBarr.async {
    // doSomething
}
concurrentQueueBarr.async(group: nil, qos: DispatchQoS.background, flags: .barrier) {

}


// Operation
let oquque = OperationQueue.init()
let op1 = BlockOperation.init {

    print("op1")
}
let op2 = BlockOperation.init {
    print("op1")
}
op2.addDependency(op1)
oquque.addOperation(op1)
oquque.addOperation(op2)

DCD 其他用法

    #pragma 信号量
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_async(queue, ^{
        
        // 相当于加锁
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"执行任务1");
        // 相当于解锁
        dispatch_semaphore_signal(semaphore);
    });
    
    dispatch_async(queue, ^{
        
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"执行任务2");
        dispatch_semaphore_signal(semaphore);
    });
    
    dispatch_async(queue, ^{
        
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"执行任务3");
        
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            
            [NSThread sleepForTimeInterval:3];
            NSLog(@"异步执行任务3");
            dispatch_semaphore_signal(semaphore);
        });
        
    });
    
    dispatch_async(queue, ^{
        
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"执行任务4");
        dispatch_semaphore_signal(semaphore);
    });
    
    #pragma barrier
    dispatch_queue_t queue2 = dispatch_queue_create("zzn.com.01", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue2, ^{
        // doSomething()
        [NSThread sleepForTimeInterval:2];
        NSLog(@"barrier:执行任务1");
    });
    dispatch_barrier_async(queue2, ^{
        NSLog(@"barrier:执行任务2");
    });
    
    #pragma group
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue3 = dispatch_queue_create("zzn.com.03", DISPATCH_QUEUE_CONCURRENT);
    
    //
    dispatch_group_async(group, queue3, ^{
        
        [NSThread sleepForTimeInterval:2];
        NSLog(@"group:执行任务1");
    });
    
    // 等同 dispatch_group_async
    dispatch_async(queue3, ^{
        
        dispatch_group_enter(group);
        [NSThread sleepForTimeInterval:2];
        dispatch_group_leave(group);
        NSLog(@"group:执行任务2");
    });
    
    
    dispatch_group_notify(group, queue3, ^{
        NSLog(@"group:执行任务3");
    });
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);