iOS學習——（轉）多線程

来源:https://www.cnblogs.com/mukekeheart/archive/2018/08/14/9133148.html
-Advertisement-
Play Games

轉載自：iOS多線程全套：線程生命周期，多線程的四種解決方案，線程安全問題，GCD的使用，NSOperation的使用 一、多線程的基本概念 進程：可以理解成一個運行中的應用程式，是系統進行資源分配和調度的基本單位，是操作系統結構的基礎，主要管理資源。 線程：是進程的基本執行單元，一個進程對應多個線 ...


轉載自：iOS多線程全套：線程生命周期，多線程的四種解決方案，線程安全問題，GCD的使用，NSOperation的使用

一、多線程的基本概念

  • 進程：可以理解成一個運行中的應用程式，是系統進行資源分配和調度的基本單位，是操作系統結構的基礎，主要管理資源。

  • 線程：是進程的基本執行單元，一個進程對應多個線程。

  • 主線程：處理UI，所有更新UI的操作都必須在主線程上執行。不要把耗時操作放在主線程，會卡界面。

  • 多線程：在同一時刻，一個CPU只能處理1條線程，但CPU可以在多條線程之間快速的切換，只要切換的足夠快，就造成了多線程一同執行的假象。

  • 線程就像火車的一節車廂，進程則是火車。車廂（線程）離開火車（進程）是無法跑動的，而火車（進程）至少有一節車廂（主線程）。多線程可以看做多個車廂，它的出現是為了提高效率。

  • 多線程是通過提高資源使用率來提高系統總體的效率。

  • 我們運用多線程的目的是：將耗時的操作放在後臺執行！

二、線程的狀態與生命周期

　　下圖是線程狀態示意圖，從圖中可以看出線程的生命周期是：新建 - 就緒 - 運行 - 阻塞 - 死亡。 

　　下麵分別闡述線程生命周期中的每一步

  • 新建：實例化線程對象

  • 就緒：向線程對象發送start消息，線程對象被加入可調度線程池等待CPU調度。

  • 運行：CPU 負責調度可調度線程池中線程的執行。線程執行完成之前，狀態可能會在就緒和運行之間來回切換。就緒和運行之間的狀態變化由CPU負責，程式員不能幹預。

  • 阻塞：當滿足某個預定條件時，可以使用休眠或鎖，阻塞線程執行。sleepForTimeInterval（休眠指定時長），sleepUntilDate（休眠到指定日期），@synchronized(self)：（互斥鎖）。

  • 死亡：正常死亡，線程執行完畢。非正常死亡，當滿足某個條件後，線上程內部中止執行/在主線程中止線程對象

  • 還有線程的exit和cancel

    • [NSThread exit]：一旦強行終止線程，後續的所有代碼都不會被執行。

    • [thread cancel]取消：並不會直接取消線程，只是給線程對象添加 isCancelled 標記。

三、多線程的四種解決方案

　　多線程的四種解決方案分別是：pthread，NSThread，GCD， NSOperation。下圖是對這四種方案進行瞭解讀和對比。

四、pThread的基本使用

//使用pthread創建線程
pthread_t thread;
NSString *name = @"wendingding";
//使用pthread創建線程
//第一個參數：線程對象地址
//第二個參數：線程屬性
//第三個參數：指向函數的執行
//第四個參數：傳遞給該函數的參數
pthread_create(&thread, NULL, run, (__bridge void *)(name));

 

五、NSThread的使用

No.1：NSThread創建線程

　　NSThread有三種創建方式：

  • init方式

  • detachNewThreadSelector創建好之後自動啟動

  • performSelectorInBackground創建好之後也是直接啟動

/** 方法一，需要start */
NSThread *thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething1:) object:@"NSThread1"];
// 線程加入線程池等待CPU調度，時間很快，幾乎是立刻執行
[thread1 start];
 
/** 方法二，創建好之後自動啟動 */
[NSThread detachNewThreadSelector:@selector(doSomething2:) toTarget:self withObject:@"NSThread2"];
 
/** 方法三，隱式創建，直接啟動 */
[self performSelectorInBackground:@selector(doSomething3:) withObject:@"NSThread3"];
 
- (void)doSomething1:(NSObject *)object {
    // 傳遞過來的參數
    NSLog(@"%@",object);
    NSLog(@"doSomething1：%@",[NSThread currentThread]);
}
 
- (void)doSomething2:(NSObject *)object {
    NSLog(@"%@",object);
    NSLog(@"doSomething2：%@",[NSThread currentThread]);
}
 
- (void)doSomething3:(NSObject *)object {
    NSLog(@"%@",object);
    NSLog(@"doSomething3：%@",[NSThread currentThread]);
}

No.2：NSThread的類方法

  • 返回當前線程

  • 阻塞休眠

  • 類方法補充

// 當前線程
[NSThread currentThread];
NSLog(@"%@",[NSThread currentThread]);

// 如果number=1，則表示在主線程，否則是子線程
列印結果：{number = 1, name = main}

//休眠多久
[NSThread sleepForTimeInterval:2];
//休眠到指定時間
[NSThread sleepUntilDate:[NSDate date]];

//退出線程
[NSThread exit];
//判斷當前線程是否為主線程
[NSThread isMainThread];
//判斷當前線程是否是多線程
[NSThread isMultiThreaded];
//主線程的對象

No.3：NSThread的一些屬性

//線程是否在執行
thread.isExecuting;
//線程是否被取消
thread.isCancelled;
//線程是否完成
thread.isFinished;
//是否是主線程
thread.isMainThread;
//線程的優先順序，取值範圍0.0到1.0，預設優先順序0.5，1.0表示最高優先順序，優先順序高，CPU調度的頻率高
 thread.threadPriority;

六、GCD的理解與使用

No.1：GCD的特點

  • GCD會自動利用更多的CPU內核

  • GCD自動管理線程的生命周期（創建線程，調度任務，銷毀線程等）

  • 程式員只需要告訴 GCD 想要如何執行什麼任務，不需要編寫任何線程管理代碼

No.2：GCD的基本概念

  • 任務（block）：任務就是將要線上程中執行的代碼，將這段代碼用block封裝好，然後將這個任務添加到指定的執行方式（同步執行和非同步執行），等待CPU從隊列中取出任務放到對應的線程中執行。

  • 同步（sync）：一個接著一個，前一個沒有執行完，後面不能執行，不開線程。

  • 非同步（async）：開啟多個新線程，任務同一時間可以一起執行。非同步是多線程的代名詞

  • 隊列：裝載線程任務的隊形結構。(系統以先進先出的方式調度隊列中的任務執行)。在GCD中有兩種隊列：串列隊列和併發隊列。

  • 併發隊列：線程可以同時一起進行執行。實際上是CPU在多條線程之間快速的切換。（併發功能只有在非同步（dispatch_async）函數下才有效）

  • 串列隊列：線程只能依次有序的執行。

  • GCD總結：將任務(要線上程中執行的操作block)添加到隊列(自己創建或使用全局併發隊列)，並且指定執行任務的方式(非同步dispatch_async，同步dispatch_sync)

No.3：隊列的創建方法

  • 使用dispatch_queue_create來創建隊列對象，傳入兩個參數，第一個參數表示隊列的唯一標識符，可為空。第二個參數用來表示串列隊列（DISPATCH_QUEUE_SERIAL）或併發隊列（DISPATCH_QUEUE_CONCURRENT）。

    // 串列隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 併發隊列
dispatch_queue_t queue1 = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);

  • GCD的隊列還有另外兩種：

  1. 主隊列：主隊列負責在主線程上調度任務，如果在主線程上已經有任務正在執行，主隊列會等到主線程空閑後再調度任務。通常是返回主線程更新UI的時候使用。dispatch_get_main_queue() 
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
      // 耗時操作放在這裡

      dispatch_async(dispatch_get_main_queue(), ^{
          // 回到主線程進行UI操作

      });
  });
  2. 全局併發隊列：全局併發隊列是就是一個併發隊列，是為了讓我們更方便的使用多線程。dispatch_get_global_queue(0, 0) 
    //全局併發隊列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//全局併發隊列的優先順序
#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高優先順序
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 預設（中）優先順序
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低優先順序
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 後臺優先順序
//iOS8開始使用服務質量，現在獲取全局併發隊列時，可以直接傳0
dispatch_get_global_queue(0, 0);

No.4：同步/非同步/任務、創建方式

  • 同步（sync）使用dispatch_sync來表示。
  • 非同步（async）使用dispatch_async。
  • 任務就是將要線上程中執行的代碼，將這段代碼用block封裝好。

代碼如下：

// 同步執行任務
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        // 任務放在這個block里
        NSLog(@"我是同步執行的任務");
 
    });
    // 非同步執行任務
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 任務放在這個block里
        NSLog(@"我是非同步執行的任務");
 
    });

No.5：GCD的使用

　　由於有多種隊列（串列/併發/主隊列）和兩種執行方式（同步/非同步），所以他們之間可以有多種組合方式。

  1. 串列同步

  2. 串列非同步

  3. 併發同步

  4. 併發非同步

  5. 主隊列同步

  6. 主隊列非同步

  • 串列同步：執行完一個任務，再執行下一個任務。不開啟新線程。

    /** 串列同步 */
- (void)syncSerial {
 
    NSLog(@"\n\n**************串列同步***************\n\n");
    // 串列隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    // 同步執行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串列同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串列同步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串列同步3   %@",[NSThread currentThread]);
        }
    });
} 

//輸出結果為順序執行，都在主線程：
串列同步1   {number = 1, name = main}
串列同步1   {number = 1, name = main}
串列同步1   {number = 1, name = main}
串列同步2   {number = 1, name = main}
串列同步2   {number = 1, name = main}
串列同步2   {number = 1, name = main}
串列同步3   {number = 1, name = main}
串列同步3   {number = 1, name = main}
串列同步3   {number = 1, name = main}

  • 串列非同步：開啟新線程，但因為任務是串列的，所以還是按順序執行任務。

    /** 串列非同步 */
- (void)asyncSerial {
 
    NSLog(@"\n\n**************串列非同步***************\n\n");
 
    // 串列隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
 
    // 非同步執行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串列非同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串列非同步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串列非同步3   %@",[NSThread currentThread]);
        }
    });
}

//輸出結果為順序執行，有不同線程：
串列非同步1   {number = 3, name = (null)}
串列非同步1   {number = 3, name = (null)}
串列非同步1   {number = 3, name = (null)}
串列非同步2   {number = 3, name = (null)}
串列非同步2   {number = 3, name = (null)}
串列非同步2   {number = 3, name = (null)}
串列非同步3   {number = 3, name = (null)}
串列非同步3   {number = 3, name = (null)}
串列非同步3   {number = 3, name = (null)}

  • 併發同步：因為是同步的，所以執行完一個任務，再執行下一個任務。不會開啟新線程。

    /** 併發同步 */
- (void)syncConcurrent {
    NSLog(@"\n\n**************併發同步***************\n\n");
    // 併發隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    // 同步執行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"併發同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"併發同步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"併發同步3   %@",[NSThread currentThread]);
        }
    });
}

//輸出結果為順序執行，都在主線程
併發同步1   {number = 1, name = main}
併發同步1   {number = 1, name = main}
併發同步1   {number = 1, name = main}
併發同步2   {number = 1, name = main}
併發同步2   {number = 1, name = main}
併發同步2   {number = 1, name = main}
併發同步3   {number = 1, name = main}
併發同步3   {number = 1, name = main}
併發同步3   {number = 1, name = main}

  • 併發非同步：任務交替執行，開啟多線程。

    /** 併發非同步 */
- (void)asyncConcurrent {
 
    NSLog(@"\n\n**************併發非同步***************\n\n");
    // 併發隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    // 非同步執行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"併發非同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"併發非同步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"併發非同步3   %@",[NSThread currentThread]);
        }
    });
}

//輸出結果為無序執行，有多條線程
併發非同步1   {number = 3, name = (null)}
併發非同步2   {number = 4, name = (null)}
併發非同步3   {number = 5, name = (null)}
併發非同步1   {number = 3, name = (null)}
併發非同步2   {number = 4, name = (null)}
併發非同步3   {number = 5, name = (null)}
併發非同步1   {number = 3, name = (null)}
併發非同步2   {number = 4, name = (null)}
併發非同步3   {number = 5, name = (null)}

  • 主隊列同步：如果在主線程中運用這種方式，則會發生死鎖，程式崩潰。

    主隊列同步造成死鎖的原因：

    1. 如果在主線程中運用主隊列同步，也就是把任務放到了主線程的隊列中。

    2. 而同步對於任務是立刻執行的，那麼當把第一個任務放進主隊列時，它就會立馬執行。

    3. 可是主線程現在正在處理syncMain方法，任務需要等syncMain執行完才能執行。

    4. syncMain執行到第一個任務的時候，又要等第一個任務執行完才能往下執行第二個和第三個任務。

    5. 這樣syncMain方法和第一個任務就開始了互相等待，形成了死鎖。

    /** 主隊列同步 */
- (void)syncMain {
 
    NSLog(@"\n\n**************主隊列同步，放到主線程會死鎖***************\n\n");
    // 主隊列
    dispatch_queue_t queue = dispatch_get_main_queue();
    //同步執行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列同步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列同步3   %@",[NSThread currentThread]);
        }
    });
    }

  • 主隊列非同步：在主線程中任務按順序執行。

    /** 主隊列非同步 */
- (void)asyncMain {
 
    NSLog(@"\n\n**************主隊列非同步***************\n\n");
    // 主隊列
    dispatch_queue_t queue = dispatch_get_main_queue();
 
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列非同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列非同步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列非同步3   %@",[NSThread currentThread]);
        }
    });
}

//輸出結果為在主線程中按順序執行
主隊列非同步1   {number = 1, name = main}
主隊列非同步1   {number = 1, name = main}
主隊列非同步1   {number = 1, name = main}
主隊列非同步2   {number = 1, name = main}
主隊列非同步2   {number = 1, name = main}
主隊列非同步2   {number = 1, name = main}
主隊列非同步3   {number = 1, name = main}
主隊列非同步3   {number = 1, name = main}
主隊列非同步3   {number = 1, name = main}

  • GCD線程之間的通訊：開發中需要在主線程上進行UI的相關操作，通常會把一些耗時的操作放在其他線程，比如說圖片文件下載等耗時操作。當完成了耗時操作之後，需要回到主線程進行UI的處理，這裡就用到了線程之間的通訊。下麵的代碼是在新開的線程中進行圖片的下載，下載完成之後回到主線程顯示圖片。

    - (IBAction)communicationBetweenThread:(id)sender {
    // 非同步
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 耗時操作放在這裡，例如下載圖片。（運用線程休眠兩秒來模擬耗時操作）
        [NSThread sleepForTimeInterval:2];
        NSString *picURLStr = @"http://www.bangmangxuan.net/uploads/allimg/160320/74-160320130500.jpg";
        NSURL *picURL = [NSURL URLWithString:picURLStr];
        NSData *picData = [NSData dataWithContentsOfURL:picURL];
        UIImage *image = [UIImage imageWithData:picData];
        // 回到主線程處理UI
        dispatch_async(dispatch_get_main_queue(), ^{
            // 在主線程上添加圖片
            self.imageView.image = image;
        });
    });
}

  • GCD柵欄：當任務需要非同步進行，但是這些任務需要分成兩組來執行，第一組完成之後才能進行第二組的操作。這時候就用了到GCD的柵欄方法dispatch_barrier_async。

    - (IBAction)barrierGCD:(id)sender {
 
    // 併發隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    // 非同步執行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"柵欄：併發非同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"柵欄：併發非同步2   %@",[NSThread currentThread]);
        }
    });
 
    dispatch_barrier_async(queue, ^{
        NSLog(@"------------barrier------------%@", [NSThread currentThread]);
        NSLog(@"******* 併發非同步執行，但是34一定在12後面 *********");
    });
 
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"柵欄：併發非同步3   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"柵欄：併發非同步4   %@",[NSThread currentThread]);
        }
    });
}

//上面代碼的列印結果如下，開啟了多條線程，所有任務都是併發非同步進行。但是第一組完成之後，才會進行第二組的操作。
柵欄：併發非同步1   {number = 3, name = (null)}
柵欄：併發非同步2   {number = 6, name = (null)}
柵欄：併發非同步1   {number = 3, name = (null)}
柵欄：併發非同步2   {number = 6, name = (null)}
柵欄：併發非同步1   {number = 3, name = (null)}
柵欄：併發非同步2   {number = 6, name = (null)}
 ------------barrier------------{number = 6, name = (null)}
******* 併發非同步執行，但是34一定在12後面 *********
柵欄：併發非同步4   {number = 3, name = (null)}
柵欄：併發非同步3   {number = 6, name = (null)}
柵欄：併發非同步4   {number = 3, name = (null)}
柵欄：併發非同步3   {number = 6, name = (null)}
柵欄：併發非同步4   {number = 3, name = (null)}
柵欄：併發非同步3   {number = 6, name = (null)}

  • GCD延時執行：當需要等待一會再執行一段代碼時，就可以用到這個方法了：dispatch_after。

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 5秒後非同步執行
    NSLog(@"我已經等待了5秒！");
});
GCD實現代碼只執行一次
使用dispatch_once能保證某段代碼在程式運行過程中只被執行1次。可以用來設計單例。
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    NSLog(@"程式運行過程中我只執行了一次！");
}); 

  • GCD快速迭代：GCD有一個快速迭代的方法dispatch_apply，dispatch_apply函數是dispatch_sync函數和Dispatch Group的關聯API,該函數按指定的次數將指定的Block追加到指定的Dispatch Queue中,並等到全部的處理執行結束。

    /*!
 *  @brief  dispatch_apply的用法
 */
- (void)dispatchApplyTest1 {
    //生成全局隊列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    
    /*! dispatch_apply函數說明
     *
     *  @brief  dispatch_apply函數是dispatch_sync函數和Dispatch Group的關聯API
     *         該函數按指定的次數將指定的Block追加到指定的Dispatch Queue中,並等到全部的處理執行結束
     *
     *  @param 10    指定重覆次數  指定10次
     *  @param queue 追加對象的Dispatch Queue
     *  @param index 帶有參數的Block, index的作用是為了按執行的順序區分各個Block
     *
     */
    dispatch_apply(10, queue, ^(size_t index) {
        NSLog(@"%zu", index);
    });
    NSLog(@"done");
    
    /*!
     *  @brief  輸出結果
     *
     2016-02-25 19:24:39.102 dispatch_apply測試[2985:165004] 0
     2016-02-25 19:24:39.102 dispatch_apply測試[2985:165086] 1
     2016-02-25 19:24:39.104 dispatch_apply測試[2985:165004] 4
     2016-02-25 19:24:39.104 dispatch_apply測試[2985:165004] 5
     2016-02-25 19:24:39.104 dispatch_apply測試[2985:165004] 6
     2016-02-25 19:24:39.103 dispatch_apply測試[2985:165088] 3
     2016-02-25 19:24:39.104 dispatch_apply測試[2985:165004] 7
     2016-02-25 19:24:39.105 dispatch_apply測試[2985:165004] 8
     2016-02-25 19:24:39.105 dispatch_apply測試[2985:165004] 9
     2016-02-25 19:24:39.102 dispatch_apply測試[2985:165087] 2
     2016-02-25 19:24:39.105 dispatch_apply測試[2985:165004] done
     *  !!!因為在Global Dispatch Queue中執行,所以各個處理的執行時間不定
     但done一定會輸出在最後的位置,因為dispatch_apply函數會等待所以的處理結束
     */
}

  • GCD 控制線程數量：GCD 不像 NSOperation 那樣有直接提供線程數量控制方法，但是通過 GCD 的 semaphore 功能一樣可以達到控制線程數量的效果。

    1. dispatch_semaphore_create(long value); 利用給定的輸出時創建一個新的可計數的信號量

    2. dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout); 如果信號量大於 0 ，信號量減 1 ，執行程式。否則等待信號量

    3. dispatch_semaphore_signal(dispatch_semaphore_t dsema); 增加信號量

      // 控制線程數量
- (void)runMaxThreadCountWithGCD
{
    dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrentRunMaxThreadCountWithGCD", DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_t serialQueue = dispatch_queue_create("serialRunMaxThreadCountWithGCD", DISPATCH_QUEUE_SERIAL);
    // 創建一個semaphore,並設置最大信號量，最大信號量表示最大線程數量
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);
    // 使用迴圈往串列隊列 serialQueue 增加 10 個任務
    for (int i = 0; i < 10 ; i++) {
        dispatch_async(serialQueue, ^{
            // 只有當信號量大於 0 的時候，線程將信號量減 1，程式向下執行
            // 否則線程會阻塞並且一直等待，直到信號量大於 0
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            dispatch_async(concurrentQueue, ^{
                NSLog(@"%@ 執行任務一次  i = %d",[NSThread currentThread],i);
                // 當線程任務執行完成之後，發送一個信號，增加信號量。
                dispatch_semaphore_signal(semaphore);
            });
        });
    }
    NSLog(@"%@ 執行任務結束",[NSThread currentThread]);
}

//執行結果如下，只有 number 3 和 number 4 這 2 個線程在執行
<nsthread: 0x60c00007c600>{number = 1, name = main} 執行任務結束
<nsthread: 0x60c00027a340>{number = 3, name = (null)} 執行任務一次  i = 0
<nsthread: 0x608000263a00>{number = 4, name = (null)} 執行任務一次  i = 1
<nsthread: 0x60c00027a340>{number = 3, name = (null)} 執行任務一次  i = 3
<nsthread: 0x608000263a00>{number = 4, name = (null)} 執行任務一次  i = 2
<nsthread: 0x60c00027a340>{number = 3, name = (null)} 執行任務一次  i = 4
<nsthread: 0x608000263a00>{number = 4, name = (null)} 執行任務一次  i = 5
<nsthread: 0x60c00027a340>{number = 3, name = (null)} 執行任務一次  i = 6
<nsthread: 0x608000263a00>{number = 4, name = (null)} 執行任務一次  i = 7
<nsthread: 0x60c00027a340>{number = 3, name = (null)} 執行任務一次  i = 8
<nsthread: 0x608000263a00>{number = 4, name = (null)} 執行任務一次  i = 9

  • GCD隊列組：非同步執行幾個耗時操作，當這幾個操作都完成之後再回到主線程進行操作，就可以用到隊列組了。GCD 的 dispatch_group_t 功能可以將多個任務分組，等待分組裡面的所有任務執行完成之後，GCD 的 dispatch_group_notify 方法可以通知。通常會配合一些常見的場景來考察，比如同時上傳 10 張圖片，全部上傳完成後通知用戶。

    // 任務分組
- (void)runGroupWithGCD
{
    dispatch_queue_t concurrentQueue = dispatch_queue_create("runGroupWithGCD", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group =  dispatch_group_create();
    for (
您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • hive 學習系列六 hive 去重辦法的思考
    方法1，建立臨時表，利用hive的collect_set 進行去重。 2，方法2， 利用row_number 去重 比如，我有一大堆的表格， 表格內容大多類似，只是有些許差別。 現在的需求是把我要統計所有的表格中，都有哪些欄位，也就是把所有的表格整合成一張大表 則可以利用row_number 進行去 ...
  • Elasticsearch 常用API
    1. Elasticsearch 常用API 1.1.數據輸入與輸出 1.1.1.Elasticsearch 文檔 #在 Elasticsearch 中，術語 文檔 有著特定的含義。它是指最頂層或者根對象, 這個根對象被序列化成 JSON 並存儲到 Elasticsearch 中，指定了唯一 ID。 ...
  • mssql sqlserver 模擬for迴圈的寫法
    轉自:http://www.maomao365.com/?p=6567 摘要: 下文講述sql腳本模擬for迴圈的寫法，如下所示: ...
  • mssql sqlserver 從指定字元串中獲取數字的方法
    轉自:http://www.maomao365.com/?p=6410 摘要: 下文主要分享從指定字元串或列中獲取數字信息，如下所示: 實驗環境:sql server 2000 ...
  • Flink基本概念
    Flink基本概念 1.The history of Flink？ 2.What is Flink？ Apache Flink是一個開源的分散式、高性能、高可用、準確的流處理框架，主要由Java代碼實現，支持實時流(stream)處理和批(batch)處理，批數據只是流數據的一個極限的特例。原生支持 ...
  • 阿裡雲RDS與ECS自建庫搭建主從複製
    前言 MySQL5.7殺手級新特性：GTID原理與實戰 具體過程如下: 1 準備工作,申請阿裡雲RDS 2 配置從實例 (slave) 3 查看是否開啟了binlog,及使用的日誌格式 4 將主實例數據全量同步到從實例 (最好下載RDS控制台的備份數據，不要mysqldump)，詳見恢復雲資料庫My ...
  • MySQL 5.7中如何定位DDL被阻塞的問題
    在上篇文章《MySQL表結構變更，不可不知的Metadata Lock》中，我們介紹了MDL引入的背景，及基本概念，從“道”的層面知道了什麼是MDL。下麵就從“術”的層面看看如何定位MDL的相關問題。 在MySQL 5.7中，針對MDL，引入了一張新表performance_schema.metad ...
  • The log scan number (620023:3702:1) passed to log scan in database 'xxxx' is not valid
    昨天一臺SQL Server 2008R2的資料庫在凌晨5點多拋出下麵告警信息： The log scan number (620023:3702:1) passed to log scan in database 'xxxx' is not valid. This error may indica... ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類