DispatchQueue swift

funcexdispathQueue(){//自定義的dispatchQueue

letserialQ =dispatch_queue_create("selrialQueue",DISPATCH_QUEUE_SERIAL)//序列佇列程式的主執行緒就是一個序列的佇列。在系統級別的多執行緒稱之為多程式

letconcurrentQ =dispatch_queue_create("conQueue",DISPATCH_QUEUE_CONCURRENT)//並行佇列

//區別序列佇列中的執行緒是序列的，要實現多執行緒的話，則需要建立多個序列佇列，當執行緒較多時，記憶體消耗的厲害；並行佇列，佇列中的執行緒，比如執行緒1，和執行緒2，先執行1的一部分，馬上執行2的一部分，這樣就實現了一個並行佇列的多執行緒。通常，程式裡面的多執行緒都是並行佇列來實現的

}

classfuncsystemQueue(){//系統提供的標準佇列

//main dispatch queue主執行緒序列佇列

letmainQ =dispatch_get_main_queue()//獲取主佇列

//Global Dispatch Queue不需要通過dispatch_queue_create函式來逐個生成Concurrent Dispatch Queue，只要獲取Global Dispatch Queue就行了

letGlobalQ =dispatch_get_global_queue(QOS_CLASS_DEFAULT,0)

//使用示例

dispatch_async(GlobalQ) {

print(NSThread.currentThread())

vara:String?

a ="執行緒變數"

//做一些耗時操作完成之後返回主執行緒

dispatch_async(dispatch_get_main_queue(), {

print(NSThread.currentThread())

print(a)

})

}

}

classfuncdispatchGroupOne(){//雖然也是group，但是有個問題，如果子執行緒中有非同步的，就有問題，所以如果子執行緒中有下載或上傳等非同步任務，這種group就不行

letqueue =dispatch_get_global_queue(QOS_CLASS_DEFAULT,0)//建立並行佇列

letgroup =dispatch_group_create()//建立組

dispatch_group_async(group, queue) {print("任務1")}

dispatch_group_async(group, queue) {print("任務2")}//向執行緒組裡新增執行緒任務

dispatch_group_async(group, queue) {print("任務3")}

//dispatch_group_notify(group, dispatch_get_main_queue()) {

//print("1,2,3都完成了")//所有任務都完成了再執行某一任務。

//}

letresult =dispatch_group_wait(group,DISPATCH_TIME_FOREVER)//------>這個是上面的翻版，意思是如果group裡面的執行緒沒結束就永遠等待下去，等的結果通過返回值表現

ifresult ==0{//返回0表示全結束了，看API

print("1,2,3都完成了")

}

}

classfuncdispatchGroupTwo(){//這種方案應對執行緒之中如果有非同步操作，比如發表說說

letgroup =dispatch_group_create()

foriin0...3{

dispatch_group_enter(group)

letqueue =dispatch_get_global_queue(QOS_CLASS_DEFAULT,0)

dispatch_async(queue, {

//耗時操作完成之後

print(i)

dispatch_group_leave(group)

})

}

dispatch_group_notify(group,dispatch_get_main_queue()) {

print("都完成了")

}

}

classfuncapply() -> () {//將第三個引數block加入到第二個引數的佇列中去。第一個引數是執行這樣的操作的次數

dispatch_apply(10,dispatch_get_global_queue(QOS_CLASS_DEFAULT,0)) { (index)in

print(index)

}

}

funcsuspendQ() -> () {//對加入佇列中未執行的block暫停或繼續其執行

//dispatch_suspend(queue)暫停

//dispatch_resume(queue)恢復

}

classfuncdispatchSet() ->() {

//let queue1 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)

//let queue2 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0)

//

//dispatch_set_target_queue(queue1, queue2)//將queue1的優先順序設定為queue2的優先順序一致設定佇列的優先順序

//

//dispatch_apply(1, queue1) { (index) in

//print("queue1----\(NSThread.currentThread())")

//}

//

//dispatch_apply(1, queue2) { (index) in

//print("queue2----\(NSThread.currentThread())")

//}

lettargetQueue =dispatch_queue_create("targetQueue",DISPATCH_QUEUE_SERIAL)

letqueue1 =dispatch_queue_create("queue1",DISPATCH_QUEUE_CONCURRENT)

letqueue2 =dispatch_queue_create("queue2",DISPATCH_QUEUE_CONCURRENT)

//targetQueue是序列佇列，如果希望queue1與queue2同步執行，則dispatch_set_target_queue將排上用場，不這麼處理，q1與q2將並行處理

dispatch_set_target_queue(queue1, targetQueue)

dispatch_set_target_queue(queue2, targetQueue)

dispatch_async(queue1) {

foriin0...5{

NSThread.sleepForTimeInterval(0.5)

print("queue1----\(NSThread.currentThread()) ----\(i)")

}

}

dispatch_async(queue1) {

foriin0...5{

NSThread.sleepForTimeInterval(0.5)

print("queue1 again----\(NSThread.currentThread()) ----\(i)")

}

}

dispatch_async(queue2){

foriin0...5{

NSThread.sleepForTimeInterval(0.5)

print("queue2----\(NSThread.currentThread()) ----\(i)")

}

}

}

classfuncbarrier() {//作用非同步執行緒barrier前面的執行緒執行結束,再繼續執行後面的程式碼1.實現高效率的資料庫訪問和檔案訪問2.避免資料競爭q1,q2次序不定，q3,q4次序不定。但是肯定是q1,q2執行完後才執行q3,q4

letqueue =dispatch_queue_create("queue",DISPATCH_QUEUE_CONCURRENT)

dispatch_async(queue) {

print("----1\(NSThread.currentThread())")

}

dispatch_async(queue) {

print("----2\(NSThread.currentThread())")

NSThread.sleepForTimeInterval(5)

}

dispatch_barrier_async(queue) {

print("5s delay continue running")

}

dispatch_async(queue) {

print("----3\(NSThread.currentThread())")

}

dispatch_async(queue) {

print("----4\(NSThread.currentThread())")

}

}

classfuncSemaphore() -> () {

letgroupQ =dispatch_group_create()

letsemQueue =dispatch_semaphore_create(10)//建立訊號量為10的訊號佇列

lettaskQueue =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)

foriin0...20{

dispatch_semaphore_wait(semQueue,DISPATCH_TIME_FOREVER)//訊號量-1如果總訊號量為0則永遠等待下去

dispatch_group_async(groupQ, taskQueue, {

print("-----\(i)")

NSThread.sleepForTimeInterval(5)

dispatch_semaphore_signal(semQueue)//訊號量+1

})

}

dispatch_group_notify(groupQ,dispatch_get_main_queue()) {

print("我執行完了")

}//執行這段程式碼可以發現，使用訊號量配合group可以實現同一時刻非同步執行的執行緒的個數，從而實現併發控制，原理是主執行緒每迴圈10次,訊號量就為0主執行緒進入等待。開闢了10個子執行緒之後，每個子執行緒都被阻塞5s，阻塞完成後，每個子執行緒又各自將訊號量+1這樣訊號總量又為10，從而進入下一個迴圈。由於cup運算速度極快，每一組子執行緒之間的先後次序可以認為是同一時刻。這樣就實現了併發控制

}