2. 程式人生 > >iOS-多執行緒程式設計學習之GCD——序列佇列和併發佇列(五)

iOS-多執行緒程式設計學習之GCD——序列佇列和併發佇列(五)

阿新 • • 發佈：2019-01-31

  Grand Central Dispatch(GCD)有很多部分構成，例如有很好的語言特性，執行庫，還提供了系統的、高效的方式來支援具有多核處理器的iOS和OS X裝置進行併發事件處理。
  BSD子系統，CoreFoundation和Cocoa APIs都已經使用這個增強特性來進行擴充套件了，因為它可以使得你的系統和應用執行的更快，更有效率，響應更及時。GCD是執行在系統級別的，他可以更好的滿足應用執行時的需求，更合理排程有限的系統資源。
  GCD並不是被限制只能在系統級別應用上使用的，我們可以在更高層的應用上也使用它。但是一般情況下我們還可以考慮Cocoa中是否有類似的物件可以實現相似的功能，例如NSOperation，它也提供了很簡單便捷的方式來進行併發任務處理【

傳送門——iOS-多執行緒程式設計學習之NSOperation(四)】。

一、GCD與ARC

  當使用Objective-C來構建應用時，所有的dispatch obeject都是Objective-C型別的物件。所以當在應用中開啟了ARC(自動引用計數)時，這些dispatch obeject也會想OC的物件一樣被自動的傳送retain和release訊息。當ARC被禁用時（也就是進行MRC手動記憶體管理時），可以通過使用dispatch_retain和dispatch_release來實現類似OC物件的retain和release操作。

二、建立任務佇列

GCD中的佇列主要分兩種。

  • 併發佇列：允許多個任務同時執行。
  • 序列佇列：任務按順序依次執行。

  系統預設有一個和主執行緒繫結的序列佇列，還有一個全域性的併發佇列。這兩個佇列都可以通過響應的方法來獲得。

2.1 獲得主執行緒的序列佇列

呼叫這個方法獲取主執行緒佇列時，該佇列是由主執行緒來自動建立的。

    dispatch_queue_t mainQueue = dispatch_get_main_queue();

2.2 獲得全域性的併發佇列

  獲取全域性併發佇列的方法中有兩個引數，第二個引數暫時沒有使用，預設傳值0就好。第一個引數表示佇列的優先順序，其中優先順序主要分為4種。

  • DISPATCH_QUEUE_PRIORITY_HIGH 2，優先順序高
  • DISPATCH_QUEUE_PRIORITY_DEFAULT 0，預設優先順序，中
  • DISPATCH_QUEUE_PRIORITY_LOW -2，優先順序低
  • DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN，後臺模式，優先順序最低
        dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

2.3 建立自定義的佇列

  建立自定義的佇列主要有兩種，一種是序列佇列，一種是並行佇列。在建立自定義佇列時會需要傳兩個引數，第一個為佇列的名稱，第二個為表示佇列型別的常量（序列還是並行）。

DISPATCH_QUEUE_SERIAL //序列佇列
DISPATCH_QUEUE_CONCURRENT //並行佇列

程式碼也很簡單。

    //序列佇列
    dispatch_queue_t serialQueue = dispatch_queue_create("com.lysongzi.serial", DISPATCH_QUEUE_SERIAL);

    //並行佇列
    dispatch_queue_t concurrentQueue = dispatch_queue_create("com.lysongzi.concurrent", DISPATCH_QUEUE_CONCURRENT);

三、同步和非同步

  當我們建立了佇列之後，我們需要把任務新增到佇列中，並指定以同步還是非同步的方式執行新增到佇列中的任務。
  同步，其會在當前執行緒立即執行新增的任務(無論是序列還是並行佇列都如此)。
  非同步，其會新建立一個新的執行緒來執行任務。而非同步對於序列和並行佇列的又不一樣的意義的。
  對於非同步執行的序列佇列的話，新新增的多個任務會在新建立的執行緒中依次執行，即一個執行完在執行另一個任務，有點類似同步執行的樣子（其區別可以看做是同步不會建立新的執行緒，而非同步會建立新的執行緒，且只建立一個）。我們可以看一下例子。

    -(void)testSerialQueue
    {
        //建立序列佇列,傳入引數為DISPATCH_QUEUE_SERIAL
        self.serialQueue = dispatch_queue_create("com.lysongzi.serial", DISPATCH_QUEUE_SERIAL);

        //同步執行佇列中的任務，會立即在當前執行緒執行該任務
        dispatch_sync(self.serialQueue, ^{
            NSLog(@"這裡是同步執行的序列佇列01。===> %@", [NSThread currentThread]);
        });

        //非同步執行任務，會新開一個執行緒，多個任務按順序執行
        dispatch_async(self.serialQueue, ^{
            for (int i = 0; i < 3; i++) {
                NSLog(@"序列01 ===> %d ===> %@", i, [NSThread currentThread]);
            }
        });

        dispatch_sync(self.serialQueue, ^{
            NSLog(@"這裡是同步執行的序列佇列02。===> %@", [NSThread currentThread]);
        });

        dispatch_async(self.serialQueue, ^{
            for (int i = 0; i < 3; i++) {
                NSLog(@"序列02 ===> %d ===> %@", i, [NSThread currentThread]);
            }
        });

        dispatch_async(self.serialQueue, ^{
            for (int i = 0; i < 3; i++) {
                NSLog(@"序列03 ===> %d ===> %@", i, [NSThread currentThread]);
            }
        });
    }

  然後我們看一下輸出結果。我們會發現使用同步方式執行的任務都會被立即執行，並且是在當前執行緒（主執行緒）中執行的。而用非同步方式的任務則會在新建立的執行緒(number=2)中執行，並且它們是按照一定順序執行的（序列01->序列02->序列03）。

2016-02-26 22:17:34.745 GCDDemon[4084:422492] 這裡是同步執行的序列佇列01。===> <NSThread: 0x100103080>{number = 1, name = main}
2016-02-26 22:17:34.747 GCDDemon[4084:422514] 序列01 ===> 0 ===> <NSThread: 0x100103a70>{number = 2, name = (null)}
2016-02-26 22:17:34.747 GCDDemon[4084:422514] 序列01 ===> 1 ===> <NSThread: 0x100103a70>{number = 2, name = (null)}
2016-02-26 22:17:34.747 GCDDemon[4084:422514] 序列01 ===> 2 ===> <NSThread: 0x100103a70>{number = 2, name = (null)}
2016-02-26 22:17:34.748 GCDDemon[4084:422492] 這裡是同步執行的序列佇列02。===> <NSThread: 0x100103080>{number = 1, name = main}
2016-02-26 22:17:34.748 GCDDemon[4084:422514] 序列02 ===> 0 ===> <NSThread: 0x100103a70>{number = 2, name = (null)}
2016-02-26 22:17:34.748 GCDDemon[4084:422514] 序列02 ===> 1 ===> <NSThread: 0x100103a70>{number = 2, name = (null)}
2016-02-26 22:17:34.748 GCDDemon[4084:422514] 序列02 ===> 2 ===> <NSThread: 0x100103a70>{number = 2, name = (null)}
2016-02-26 22:17:34.748 GCDDemon[4084:422514] 序列03 ===> 0 ===> <NSThread: 0x100103a70>{number = 2, name = (null)}
2016-02-26 22:17:34.748 GCDDemon[4084:422514] 序列03 ===> 1 ===> <NSThread: 0x100103a70>{number = 2, name = (null)}
2016-02-26 22:17:34.748 GCDDemon[4084:422514] 序列03 ===> 2 ===> <NSThread: 0x100103a70>{number = 2, name = (null)}

  我們再來看看如果是併發佇列的話，使用同步方式執行任何則和序列佇列一樣。而使用非同步方式執行任務的話，新新增的任務都會放到新建立的執行緒，即每個任務在單獨執行緒中，並且所有的任務都是併發執行的，而不像序列佇列是有順序的。如果是非同步方式執行的話，則每個任務都會新開一個執行緒，並且這些任務是併發執行的。我們來看一下下面這個例子。

    -(void)testConcurrentQueue
    {
        //建立併發佇列，傳入引數為DISPATCH_QUEUE_CONCURRENT
        self.concurrentQueue = dispatch_queue_create("com.lysongzi.concurrent", DISPATCH_QUEUE_CONCURRENT);

        //同步執行佇列中的任務，會立即執行該任務
        dispatch_sync(self.concurrentQueue, ^{
            for (int i = 0; i < 3; i++) {
                NSLog(@"併發同步01 ===> %d ===> %@", i, [NSThread currentThread]);
            }
        });

        dispatch_sync(self.concurrentQueue, ^{
            for (int i = 0; i < 3; i++) {
                NSLog(@"併發同步02 ===> %d ===> %@", i, [NSThread currentThread]);
            }
        });

        //非同步執行併發佇列
        dispatch_async(self.concurrentQueue, ^{
            for (int i = 0; i < 5; i++) {
                NSLog(@"併發非同步01 ===> %d ===> %@", i, [NSThread currentThread]);
            }
        });

        dispatch_async(self.concurrentQueue, ^{
            for (int i = 0; i < 5; i++) {
                NSLog(@"併發非同步02 ===> %d ===> %@", i, [NSThread currentThread]);
            }
        });

        dispatch_async(self.concurrentQueue, ^{
            for (int i = 0; i < 5; i++) {
                NSLog(@"併發非同步03 ===> %d ===> %@", i, [NSThread currentThread]);
            }
        });
    }

然後我們來看一下輸出結果。這剛好驗證了我們的說法。

2016-02-26 22:43:17.553 GCDDemon[4223:436777] 併發同步01 ===> 0 ===> <NSThread: 0x100108c80>{number = 1, name = main}
2016-02-26 22:43:17.554 GCDDemon[4223:436777] 併發同步01 ===> 1 ===> <NSThread: 0x100108c80>{number = 1, name = main}
2016-02-26 22:43:17.554 GCDDemon[4223:436777] 併發同步01 ===> 2 ===> <NSThread: 0x100108c80>{number = 1, name = main}
2016-02-26 22:43:17.554 GCDDemon[4223:436777] 併發同步02 ===> 0 ===> <NSThread: 0x100108c80>{number = 1, name = main}
2016-02-26 22:43:17.554 GCDDemon[4223:436777] 併發同步02 ===> 1 ===> <NSThread: 0x100108c80>{number = 1, name = main}
2016-02-26 22:43:17.554 GCDDemon[4223:436777] 併發同步02 ===> 2 ===> <NSThread: 0x100108c80>{number = 1, name = main}
2016-02-26 22:43:17.555 GCDDemon[4223:436826] 併發非同步03 ===> 0 ===> <NSThread: 0x100700110>{number = 3, name = (null)}
2016-02-26 22:43:17.555 GCDDemon[4223:436826] 併發非同步03 ===> 1 ===> <NSThread: 0x100700110>{number = 3, name = (null)}
2016-02-26 22:43:17.555 GCDDemon[4223:436825] 併發非同步02 ===> 0 ===> <NSThread: 0x1002000a0>{number = 2, name = (null)}
2016-02-26 22:43:17.555 GCDDemon[4223:436826] 併發非同步03 ===> 2 ===> <NSThread: 0x100700110>{number = 3, name = (null)}
2016-02-26 22:43:17.555 GCDDemon[4223:436825] 併發非同步02 ===> 1 ===> <NSThread: 0x1002000a0>{number = 2, name = (null)}
2016-02-26 22:43:17.555 GCDDemon[4223:436826] 併發非同步03 ===> 3 ===> <NSThread: 0x100700110>{number = 3, name = (null)}
2016-02-26 22:43:17.555 GCDDemon[4223:436825] 併發非同步02 ===> 2 ===> <NSThread: 0x1002000a0>{number = 2, name = (null)}
2016-02-26 22:43:17.555 GCDDemon[4223:436826] 併發非同步03 ===> 4 ===> <NSThread: 0x100700110>{number = 3, name = (null)}
2016-02-26 22:43:17.556 GCDDemon[4223:436824] 併發非同步01 ===> 0 ===> <NSThread: 0x10010aec0>{number = 4, name = (null)}
2016-02-26 22:43:17.582 GCDDemon[4223:436825] 併發非同步02 ===> 3 ===> <NSThread: 0x1002000a0>{number = 2, name = (null)}
2016-02-26 22:43:17.582 GCDDemon[4223:436824] 併發非同步01 ===> 1 ===> <NSThread: 0x10010aec0>{number = 4, name = (null)}
2016-02-26 22:43:17.582 GCDDemon[4223:436825] 併發非同步02 ===> 4 ===> <NSThread: 0x1002000a0>{number = 2, name = (null)}
2016-02-26 22:43:17.582 GCDDemon[4223:436824] 併發非同步01 ===> 2 ===> <NSThread: 0x10010aec0>{number = 4, name = (null)}
2016-02-26 22:43:17.582 GCDDemon[4223:436824] 併發非同步01 ===> 3 ===> <NSThread: 0x10010aec0>{number = 4, name = (null)}
2016-02-26 22:43:17.582 GCDDemon[4223:436824] 併發非同步01 ===> 4 ===> <NSThread: 0x10010aec0>{number = 4, name = (null)}

原始碼

參考資料

相關推薦

iOS-多執行緒程式設計學習之GCD——序列佇列和併發佇列(五)

  Grand Central Dispatch(GCD)有很多部分構成，例如有很好的語言特性，執行庫，還提供了系統的、高效的方式來支援具有多核處理器的iOS和OS X裝置進行併發事件處理。   BSD子系統，CoreFoundation和Cocoa APIs

IOS 多執行緒程式設計指南之NSThread

1.NSThread基本運用 app啟動時預設都是,包括ViewController裡執行的都是在主執行緒執行的 當計算了過大的時候會造成執行緒阻塞,比如點選按鈕執行下面的方法,只有計算完,結束後,程式才能繼續執行,如果是死迴圈的話,會一直佔用主執行緒,導致

iOS多執行緒程式設計之Grand Central Dispatch(GCD)介紹和使用

介紹： Grand Central Dispatch 簡稱（GCD）是蘋果公司開發的技術，以優化的應用程式支援多核心處理器和其他的對稱多處理系統的系統。這建立在任務並行執行的執行緒池模式的基礎上的。它首次釋出在Mac OS X 10.6 ，iOS 4及以上也可用。 設計：

多執行緒程式設計指南之執行緒管理（iOS，Mac os ）

1.執行緒成本 多執行緒會佔用記憶體和效能資源。 多執行緒另外一個需要考慮的成本是成產成本。設計一個執行緒應用有時候會需要根本性的改變你應用的資料結構的組織方式。要做這些改變可能需要避免使用同步，因為本身設計不好的應用可能會造成巨大的

iOS多執行緒程式設計（四）------ GCD（Grand Central Dispatch）

一、簡介 是基於C語言開發的一套多執行緒開發機制，也是目前蘋果官方推薦的多執行緒開發方法，用起來也最簡單，只是它基於C語言開發，並不像NSOperation是面向物件的開發，而是完全面向過程的。如果使用GCD，完全由系統管理執行緒，我們不需要編

iOS多執行緒程式設計技術NSThread、Cocoa NSOperation、GCD三者使用詳解

簡介 iOS有三種多執行緒程式設計的技術，分別是：（一）NSThread （二）Cocoa NSOperation （三）GCD（全稱：Grand Central Dispatch）三種方式的優缺點介紹: 1）NSThread優點：NSThread 比其他兩個輕量級缺點

Java多執行緒程式設計學習總結（二）

  （尊重勞動成果，轉載請註明出處：https://blog.csdn.net/qq_25827845/article/details/84894463冷血之心的部落格） 系列文章： Java多執行緒程式設計學習總結（一） Java多執行緒程式設計學習總結（二） 前

Java 多執行緒程式設計學習總結（一）

定義篇 程序(Process)和執行緒(Thread) 怎樣實現多工處理（Multitasking）？ 多工處理是同時執行多個任務的過程。我們使用多工處理來利用 CPU。可通過兩種方式實現多工處理: · 基於程序的多工 (多重處理) · 基於執行緒的多工處理

多執行緒程式設計學習（1）物件及變數的併發訪問

程序：計算機中的程式關於某資料集合上的一次執行活動，是系統進行資源分配和排程的基本單位，是作業系統結構的基礎。 執行緒：在程序中獨立執行的子任務。 在java中以下3種方法可以終止正在執行的執行緒： 1) 使用退出標誌，使執行緒正常退出，也就是當run方法完成後執行緒終

java多執行緒程式設計入門之鎖的使用

package com.CUPK.lsz.TraditionalThread; //實現互斥的第一種方法：作為定義詞修飾程式碼 public class TraditonalThreadSynchronized1 { final Outputer outputer = new Outputer(

【C++多執行緒程式設計學習(1)】-CPU個數、CPU核心數、CPU執行緒數

轉自：CPU個數、CPU核心數、CPU執行緒數(by kimsimple)   CPU個數即CPU晶片個數。 CPU核心數是指物理上，也就是硬體上存在著幾個核心。比如，雙核就是包括2個相對獨立的CPU核心單元組，四核就包含4個相對獨立的CPU核心單元組。 CPU執行緒數是一

Linux多執行緒程式設計講解之系列六

執行緒安全介紹 在目前的電腦科學中，執行緒是作業系統排程的最小單元，程序是資源分配的最小單元。在大多數作業系統中，一個程序可以同時派生出多個執行緒。這些執行緒獨立執行，共享程序的資源。在單處理器系統中，多執行緒通過分時複用技術來技術，處理器在不同的執行緒間切換，從而更高效地利用系統 CPU資源。

Linux多執行緒程式設計講解之系列五

在Posix執行緒規範中還有幾個輔助函式難以歸類，暫且稱其為雜項函式，主要包括pthread_self()、pthread_equal()和pthread_once()三個，另外還有一個LinuxThreads非可移植性擴充套件函式pthread_kill_other_t

Linux多執行緒程式設計講解之系列一

Linux執行緒概述瞭解如何正確運用執行緒是每一個優秀程式設計師必備的素質。執行緒類似於程序。如同程序，執行緒由核心按時間分片進行管理。在單處理器系統中，核心使用時間分片來模擬執行緒的併發執行，這種方式和程序的相同。而在多處理器系統中，如同多個程序，執行緒實際上一樣可以併發

C++：多執行緒程式設計學習:利用多執行緒進行歸併排序。

首先學習一下簡單的執行緒知識 ：(1)pthread_join函式,用來阻塞當前的執行緒。直到指定執行緒結束。 ：(2)pthread_create,用來建立執行緒。 下面的程式碼開了五個執行緒用來輸出一個函式。 #include <pth

Linux多執行緒程式設計學習(1)--執行緒的概念和執行緒控制

Linux多執行緒程式設計學習總結 一.執行緒的概念 1.什麼是執行緒？ 2.程序和執行緒的區別 3.程序和執行緒的關係 4.執行緒的優缺點 4.1 優點 4.2 缺點 5.執行

【自用】java多執行緒程式設計學習筆記（程式碼片段來源於網路）

執行緒的基本概念 執行緒是在邏輯上等同於作業系統中說的程序，是程序的細分。比如我們使用同一個軟體同時對電腦進行體檢和防毒的時候，我們就是開啟了那個軟體的程序的兩個執行緒，在邏輯上這兩個執行緒是同時被cpu執行的。 執行緒的生命週期 執行緒的生命週期分為建立，就緒，執行，

Java多執行緒程式設計學習

擴充套件Java.lang.Thread類 實現java.lang.Runnable介面 Thread和Runnable的區別 執行緒狀態轉換 執行緒排程 程序：每個程序都有獨立的程式碼和資料空間(程序上下文)，程序間的切換比較大，一個進行包含1-n

IOS 多執行緒知識學習

在這篇文章中，我將為你整理一下 iOS 開發中幾種多執行緒方案，以及其使用方法和注意事項。當然也會給出幾種多執行緒的案例，在實際使用中感受它們的區別。還有一點需要說明的是，這篇文章將會使用 Swift 和 Objective-c 兩種語言講解，雙語幼兒園。O

多執行緒程式設計學習筆記——執行緒同步（三）

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; //引入執行緒 using System.Diagnostics; namesp