迅速GCDの簡単な使用

戻るメインスレッドへ

        {DispatchQueue.main.async 
           //プリント（「ここでメインスレッドが」）
        }

遅延実行

        DEADLINE = DispatchTime.now LET（）+ 5.0 
        DispatchQueue.global（）asyncAfter。（DEADLINE：DEADLINE）{ 
            //印刷（ "ここでは遅延やります"）
        }

非同期スレッドを開きます

        {DispatchQueue.main.asyncの
            印刷（「実行の新しい非同期スレッドを開きます」）
        }

スレッドの同期を開きます。

DispatchQueue.global（）。同期{ 
            
}

スレッドの優先順位

        キューVAR：DispatchQueue DispatchQueue.global =（）// 
        //DispatchQueue.GlobalQueuePriority選択4高、defaultを、低バックグラウンドがあります。
        キュー= DispatchQueue.global（優先順位：DispatchQueue.GlobalQueuePriority.background）背景// 
        //は、非同期タスク実行キュー
        queue.async { 
            //印刷する（「新しいスレッドの実行を開きます」）
        }

パケットの実行

       グループ= DispatchGroup LET（）
        キュー= DispatchQueue.global（優先順位：DispatchQueue.GlobalQueuePriority.default）//デフォルトの優先順位を行う
        0で私のため.. <10 { 
            //非同期タスク実行キュー
            queue.async（グループ：グループ、実行：{ 
                印刷（ "queue.async（グループ：グループ\（I）"）
            }）
        } 
        //パケットキューの実行が完了した後
        group.notifyを（キュー：キュー）{ 
            印刷（ "dispatch_group_notify"）
        }

シリアルキュー：一つだけスレッドが順次実行順次添加することにより、キューの動作に添加されます。

       serialQueue = DispatchQueue LET（ラベル： "yangj"、属性：[]）
        I 0で.. <10 { 
            //非同期タスク実行キュー
            serialQueue.async { 
                印刷（ "serialQueue.async \（I）"）
            } 
        }

同時キュー：タスクの優先度に高度な確保しながら、複数のスレッドがありますが、それは、使用可能なプロセッサ上のキューにおけるこれらの構成の動作の後に来ます。

        globalQueue = DispatchQueue.global LET（優先順位：DispatchQueue.GlobalQueuePriority.default）
        I 0で.. <10 { 
            //非同期タスク実行キュー
            globalQueue.async { 
                印刷（ "globalQueue.async \（I）"）
            } 
        }

セマフォ

       // DispatchSemaphore信号の大きさが1であるので、一つだけを実行することができる
        せセマフォDispatchSemaphore =（値：1）
        LET = DispatchQueue.globalキュー（）
        queue.async { 
            semaphore.wait（）
            LET締め切り= DispatchTime.now（） 3.0 + 
            DispatchQueue.global（）asyncAfter。（締め切り：締め切り）{ 
                印刷（ "----------------- 1"）; 
                semaphore.signal（）
            } 
            
        } 
        queue.async { 
            semaphore.wait（）
            させDispatchTime.now締め切り=（）+ 10.0 
            DispatchQueue.global（）asyncAfter（締め切り：締め切り）。{ 
                 印刷（ "2 -----------------" ）;
                 semaphore.signal（） 
            }
            
        } 
        queue.async { 
            semaphore.wait（）
            させ締切= DispatchTime.now（）+ 2.0 
            DispatchQueue.global（）asyncAfter（締切：締め切り）。{ 
                印刷（ "--------- -------- 3" ）。
                semaphore.signal（）
            } 
            
        }

dispatch_group_enterのOC使用

        //設定したスケジュールを作成
        しましょうworkingGroup DispatchGroup =（）を
        複数の列を作成// 
        workingQueue = DispatchQueueをしましょう（ラベル： "request_queueを"）
        
        //非同期ネットワーク要求をエミュレート
        @を登録
        workingGroup.enter（）
        workingQueue.async { 
            スレッドを。 SLEEPは（forTimeInterval :. 1）
            印刷（ "ポートデータ要求が完了した"）
            //定め
            workingGroup.leaveを（）
        } 
        
        //非同期ネットワーク要求Bをエミュレート
        @が登録
        workingGroup.enter（）
        workingQueue.async { 
            のThread.sleepを（forTimeInterval :. 1）
            印刷（ "ポートBのデータ要求完了"） 
            //着手します
            workingGroup.leave（） 
        } 
        
        印刷（「私は、ほとんどの印刷実行中に、非同期操作の後に起動しています」）
        
        //グループのタスクが終了するスケジュール
        workingGroup.notify（キュー：workingQueue）{ 
            印刷（「AおよびインタフェースBインタフェースデータ要求）が二つのデータ・インタフェース」をマージし始める！完了しています
        }

dispatch_group_enterのOC使用

おすすめ