iOS --- 多线程之GCD

GCD（Grand Central Dispatch）是一套低层级的C语言API，通过GCD，可向队列中添加一段代码段（block或C函数指针），而不需要直接和线程打交道。
GCD在后端管理着一个线程池，不仅决定着代码块在哪个线程中执行，还可根据可用的系统资源对线程进行管理，从而解决了线程创建管理等的问题。
GCD的使用方式非常灵活，是目前iOS开发中最为常用的多线程技术。

异步逻辑，同步更新

GCD的最常见用法如下，因UIKit不是线程安全的，所以更新UI等操作尽量放在主线程中执行。

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), { () -> Void in 
        // 网络请求等耗时的逻辑计算放在异步线程中，以免block住当前UI的更新     
        dispatch_async(dispatch_get_main_queue(), { () -> Void in 
                  // 在主线程中更新UI  
        });
});

同步操作dispatch_sync会等待block中的代码执行完毕之后在继续执行其他代码，而异步操作dispatch_async则不会。

dispatch_queue_t

dispatch_queue_t是GCD队列，包括全局队列、主队列和自定义队列。

var myQueue: dispatch_queue_t = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
myQueue = dispatch_queue_create("com.chris.threads", DISPATCH_QUEUE_SERIAL);//串行队列
myQueue = dispatch_queue_create("com.chris.threads", DISPATCH_QUEUE_CONCURRENT);//并行队列

dispatch_once

dispatch_once用于执行一次性的任务，是线程安全的。

var onceToken: dispatch_once_t = 0;
dispatch_once(&onceToken, { () -> Void in 
    print("onceToken task");
});

dispatch_once常用于单例模式中：

class CSSingleton: NSObject { 
    class func sharedInstance() -> CSSingleton { 
        struct csInstance { 
            static var instance: CSSingleton? 
            static var onceToken: dispatch_once_t = 0 
        } 
        dispatch_once(&csInstance.onceToken) { () -> Void in 
            csInstance.instance = CSSingleton() 
        } 
        return csInstance.instance! 
    }
}

dispatch_apply

dispatch_apply用于重复执行某个任务，默认是同步并行执行的，会阻塞线程。可使用dispatch_async包装成异步执行。

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), { () -> Void in 
    dispatch_apply(10, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), { (index: Int) -> Void in 
        print(index) 
        print(NSThread.currentThread()) 
    });
});

dispatch_after

dispatch_after一般用于延时操作，可用于延时更新UI等。

let myTime: dispatch_time_t = dispatch_time(DISPATCH_TIME_NOW, (Int64)(NSEC_PER_SEC * 2));
dispatch_after(myTime, dispatch_get_main_queue(), { () -> Void in 
    // update something
});

dispatch_group_async

dispatch_group_async可用来监听一组任务是否执行完成，完成之后得到通知dispatch_group_notify再去执行其他的操作。

let myQueue: dispatch_queue_t = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
let myGroup = dispatch_group_create();
dispatch_group_async(myGroup, myQueue, { () -> Void in 
    dispatch_async(dispatch_get_main_queue(), { () -> Void in 
        // operation 1 
    });
});
dispatch_group_async(myGroup, myQueue, { () -> Void in 
    dispatch_async(dispatch_get_main_queue(), { () -> Void in 
        // operation 2 
    });
});
dispatch_group_notify(myGroup, dispatch_get_main_queue(), { () -> Void in 
    // operation 3
});

这样，会等到myGroup中的任务执行完毕之后，再去执行operation 3。

dispatch_group_wait

let myQueue: dispatch_queue_t = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
let myGroup = dispatch_group_create()
dispatch_group_async(myGroup, myQueue, { () -> Void in
    dispatch_async(dispatch_get_main_queue(), { () -> Void in 
        // operation 1 
    })
})
dispatch_group_async(myGroup, myQueue, { () -> Void in 
    dispatch_async(dispatch_get_main_queue(), { () -> Void in 
        //operation 2 
    })
})
// 同步，如操作数据库要等待完成之后才让用户操作其他的dispatch_group_wait(myGroup, dispatch_time(DISPATCH_TIME_NOW, (Int64)(NSEC_PER_SEC * 10)))

dispatch_suspend/dispatch_resume

dispatch_suspend/dispatch_resume分别用于暂停和继续队列。已加入该队列的任务不会暂停，未加入的会暂停加入进去。

let myQueue: dispatch_queue_t = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
// 不能暂停系统队列和主队列。
// 已加入队列的任务不会暂停，而未加入的会暂停。dispatch_suspend(myQueue)
// dispatch_resume(myQueue)

dispatch_barrier_async

dispatch_barrier_async是在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行

// 会强制阻塞队列，而只执行指定的任务
// 因此不能传入global queue或main queue，因其还要做其他事情。 dispatch_barrier_async(dispatch_queue_create("myQueue", DISPATCH_QUEUE_CONCURRENT), { () -> Void in 
    self.addMyArray(1)
});

DemoDemo地址

DemoMultiThread