2. 程式人生 > >16、iOS多線程篇：NSThread

16、iOS多線程篇：NSThread

阿新 • • 發佈：2017-07-15
val thread rec getc ive 同時 開放 orm 通信

一、什麽是NSThread

　　NSThread是基於線程使用，輕量級的多線程編程方法（相對GCD和NSOperation），一個NSThread對象代表一個線程，需要手動管理線程的生命周期，處理線程同步等問題。

二、NSThread方法介紹

１）動態創建
    NSThread * newThread = [[NSThread alloc]initWithTarget:self selector:@selector(threadRun) object:nil];

　　動態方法返回一個新的thread對象，需要調用start方法來啟動線程

２）靜態創建
    [NSThread detachNewThreadSelector:@selector(threadRun) toTarget:self withObject:nil];

　　由於靜態方法沒有返回值，如果需要獲取新創建的thread，需要在selector中調用獲取當前線程的方法

３）線程開啟
    [newThread start];
４）線程暫停
    [NSThread sleepForTimeInterval:1.0];　（以暫停一秒為例）
    [NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:1.0]];

　　NSThread的暫停會有阻塞當前線程的效果

５）線程取消
    [newThread cancel];

　　取消線程並不會馬上停止並退出線程，僅僅只作（線程是否需要退出）狀態記錄

６）線程停止
    [NSThread exit];

　　停止方法會立即終止除主線程以外所有線程（無論是否在執行任務）並退出，需要在掌控所有線程狀態的情況下調用此方法，否則可能會導致內存問題。

７）獲取當前線程
    [NSThread currentThread];
８）獲取主線程
    [NSThread mainThread];
９）線程優先級設置

　　iOS8以前使用

    [NSThread setThreadPriority:1.0];

　　這個方法的優先級的數值設置讓人困惑，因為你不知道你應該設置多大的值是比較合適的，因此在iOS8之後，threadPriority添加了一句註釋：To be deprecated; use qualityOfService below

　　意思就是iOS8以後推薦使用qualityOfService屬性，通過量化的優先級枚舉值來設置
　　qualityOfService的枚舉值如下：
　　　　NSQualityOfServiceUserInteractive：最高優先級，用於用戶交互事件
　　　　NSQualityOfServiceUserInitiated：次高優先級，用於用戶需要馬上執行的事件
　　　　NSQualityOfServiceDefault：默認優先級，主線程和沒有設置優先級的線程都默認為這個優先級
　　　　NSQualityOfServiceUtility：普通優先級，用於普通任務
　　　　NSQualityOfServiceBackground：最低優先級，用於不重要的任務

　　比如給線程設置次高優先級：

    [newThread setQualityOfService:NSQualityOfServiceUserInitiated];

三、線程間通信

　　常用的有三種：

　　1、指定當前線程執行操作
    [self performSelector:@selector(threadRun)];
    [self performSelector:@selector(threadRun) withObject:nil];
    [self performSelector:@selector(threadRun) withObject:nil afterDelay:2.0];
　　2、（在其他線程中）指定主線程執行操作
    [self performSelectorOnMainThread:@selector(threadRun) withObject:nil waitUntilDone:YES];

　　註意：更新UI要在主線程中進行

　　3、（在主線程中）指定其他線程執行操作
    [self performSelector:@selector(threadRun) onThread:newThread withObject:nil waitUntilDone:YES]; //這裏指定為某個線程
    [self performSelectorInBackground:@selector(threadRun) withObject:nil];//這裏指定為後臺線程

四、線程同步

　　線程和其他線程可能會共享一些資源，當多個線程同時讀寫同一份共享資源的時候，可能會引起沖突。線程同步是指是指在一定的時間內只允許某一個線程訪問某個資源

[email protected]

五、線程的創建和使用實例：模擬售票

　　情景：某演唱會門票發售，在廣州和北京均開設窗口進行銷售，以下是代碼實現

     先監聽線程退出的通知，以便知道線程什麽時候退出
     [[NSNotificationCenter defaultCenter]addObserver:self selector:@selector(threadExitNotice) name:NSThreadWillExitNotification object:nil];
     設置演唱會的門票數量
     _ticketCount = 50;
     新建兩個子線程（代表兩個窗口同時銷售門票）
     NSThread * window1 = [[NSThread alloc]initWithTarget:self selector:@selector(saleTicket) object:nil];
     window1.name = @"北京售票窗口";
     [window1 start];

     NSThread * window2 = [[NSThread alloc]initWithTarget:self selector:@selector(saleTicket) object:nil];
     window2.name = @"廣州售票窗口";
     [window2 start];
     線程啟動後，執行saleTicket，執行完畢後就會退出，為了模擬持續售票的過程，我們需要給它加一個循環
     - (void)saleTicket {
         while (1) {
             //如果還有票，繼續售賣
             if (_ticketCount > 0) {
                 _ticketCount --;
                 NSLog(@"%@", [NSString stringWithFormat:@"剩余票數：%ld 窗口：%@", _ticketCount, [NSThread currentThread].name]);
                 [NSThread sleepForTimeInterval:0.2];
             }
             //如果已賣完，關閉售票窗口
             else {
                 break;
             }
         }
     }
     執行結果：
    2016-04-06 19:25:36.637 MutiThread[4705:1371666] 剩余票數：9 窗口：廣州售票窗口
    2016-04-06 19:25:36.637 MutiThread[4705:1371665] 剩余票數：8 窗口：北京售票窗口
    2016-04-06 19:25:36.839 MutiThread[4705:1371666] 剩余票數：7 窗口：廣州售票窗口
    2016-04-06 19:25:36.839 MutiThread[4705:1371665] 剩余票數：7 窗口：北京售票窗口
    2016-04-06 19:25:37.045 MutiThread[4705:1371666] 剩余票數：5 窗口：廣州售票窗口
    2016-04-06 19:25:37.045 MutiThread[4705:1371665] 剩余票數：6 窗口：北京售票窗口
    2016-04-06 19:25:37.250 MutiThread[4705:1371665] 剩余票數：4 窗口：北京售票窗口
    2016-04-06 19:25:37.250 MutiThread[4705:1371666] 剩余票數：4 窗口：廣州售票窗口
    2016-04-06 19:25:37.456 MutiThread[4705:1371666] 剩余票數：2 窗口：廣州售票窗口
    2016-04-06 19:25:37.456 MutiThread[4705:1371665] 剩余票數：3 窗口：北京售票窗口
    2016-04-06 19:25:37.661 MutiThread[4705:1371665] 剩余票數：1 窗口：北京售票窗口
    2016-04-06 19:25:37.661 MutiThread[4705:1371666] 剩余票數：1 窗口：廣州售票窗口
    2016-04-06 19:25:37.866 MutiThread[4705:1371665] 剩余票數：0 窗口：北京售票窗口
    2016-04-06 19:25:37.867 MutiThread[4705:1371666] <NSThread: 0x7fdc91e289f0>{number = 3, name = 廣州售票窗口} Will Exit
    2016-04-06 19:25:38.070 MutiThread[4705:1371665] <NSThread: 0x7fdc91e24d60>{number = 2, name = 北京售票窗口} Will Exit

　　可以看到，票的銷售過程中出現了剩余數量錯亂的情況，這就是前面提到的線程同步問題。

　　售票是一個典型的需要線程同步的場景，由於售票渠道有很多，而票的資源是有限的，當多個渠道在短時間內賣出大量的票的時候，如果沒有同步機制來管理票的數量，將會導致票的總數和售出票數對應不上的錯誤。

     我們在售票的過程中給票加上同步鎖：同一時間內，只有一個線程能對票的數量進行操作，當操作完成之後，其他線程才能繼續對票的數量進行操作。
     - (void)saleTicket {
         while (1) {
             @synchronized(self) {
                 //如果還有票，繼續售賣
                 if (_ticketCount > 0) {
                     _ticketCount --;
                     NSLog(@"%@", [NSString stringWithFormat:@"剩余票數：%ld 窗口：%@", _ticketCount, [NSThread currentThread].name]);
                     [NSThread sleepForTimeInterval:0.2];
                 }
                 //如果已賣完，關閉售票窗口
                 else {
                     break;
                 }
             }
         }
     }
     運行結果：
     2016-04-06 19:31:27.913 MutiThread[4718:1406865] 剩余票數：11 窗口：北京售票窗口
     2016-04-06 19:31:28.115 MutiThread[4718:1406866] 剩余票數：10 窗口：廣州售票窗口
     2016-04-06 19:31:28.317 MutiThread[4718:1406865] 剩余票數：9 窗口：北京售票窗口
     2016-04-06 19:31:28.522 MutiThread[4718:1406866] 剩余票數：8 窗口：廣州售票窗口
     2016-04-06 19:31:28.728 MutiThread[4718:1406865] 剩余票數：7 窗口：北京售票窗口
     2016-04-06 19:31:28.929 MutiThread[4718:1406866] 剩余票數：6 窗口：廣州售票窗口
     2016-04-06 19:31:29.134 MutiThread[4718:1406865] 剩余票數：5 窗口：北京售票窗口
     2016-04-06 19:31:29.339 MutiThread[4718:1406866] 剩余票數：4 窗口：廣州售票窗口
     2016-04-06 19:31:29.545 MutiThread[4718:1406865] 剩余票數：3 窗口：北京售票窗口
     2016-04-06 19:31:29.751 MutiThread[4718:1406866] 剩余票數：2 窗口：廣州售票窗口
     2016-04-06 19:31:29.952 MutiThread[4718:1406865] 剩余票數：1 窗口：北京售票窗口
     2016-04-06 19:31:30.158 MutiThread[4718:1406866] 剩余票數：0 窗口：廣州售票窗口
     2016-04-06 19:31:30.363 MutiThread[4718:1406866] <NSThread: 0x7ff0c1637320>{number = 3, name = 廣州售票窗口} Will Exit
     2016-04-06 19:31:30.363 MutiThread[4718:1406865] <NSThread: 0x7ff0c1420cb0>{number = 2, name = 北京售票窗口} Will Exit

　　可以看到，票的數量沒有出現錯亂的情況。

　　線程的持續運行和退出

　　我們註意到，線程啟動後，執行saleTicket完畢後就馬上退出了，怎樣能讓線程一直運行呢（窗口一直開放，可以隨時指派其賣演唱會的門票的任務），答案就是給線程加上runLoop

 ```
     先監聽線程退出的通知，以便知道線程什麽時候退出
     [[NSNotificationCenter defaultCenter]addObserver:self selector:@selector(threadExitNotice) name:NSThreadWillExitNotification object:nil];
 ```
     //設置演唱會的門票數量
     _ticketCount = 50;
     新建兩個子線程（代表兩個窗口同時銷售門票）
     NSThread * window1 = [[NSThread alloc]initWithTarget:self selector:@selector(thread1) object:nil];
     [window1 start];

     NSThread * window2 = [[NSThread alloc]initWithTarget:self selector:@selector(thread2) object:nil];
     [window2 start];
     接著我們給線程創建一個runLoop
     - (void)thread1 {
         [NSThread currentThread].name = @"北京售票窗口";
         NSRunLoop * runLoop1 = [NSRunLoop currentRunLoop];
         [runLoop1 runUntilDate:[NSDate date]]; //一直運行
     }

     - (void)thread2 {
         [NSThread currentThread].name = @"廣州售票窗口";
         NSRunLoop * runLoop2 = [NSRunLoop currentRunLoop];
         [runLoop2 runMode:NSDefaultRunLoopMode beforeDate:[NSDate dateWithTimeIntervalSinceNow:10.0]]; //自定義運行時間
     }
     然後就可以指派任務給線程了，這裏我們讓兩個線程都執行相同的任務（售票）
     [self performSelector:@selector(saleTicket) onThread:window1 withObject:nil waitUntilDone:NO];
     [self performSelector:@selector(saleTicket) onThread:window2 withObject:nil waitUntilDone:NO];
     運行結果：
     2016-04-06 19:43:22.585 MutiThread[4762:1478200] 剩余票數：11 窗口：北京售票窗口
     2016-04-06 19:43:22.788 MutiThread[4762:1478201] 剩余票數：10 窗口：廣州售票窗口
     2016-04-06 19:43:22.993 MutiThread[4762:1478200] 剩余票數：9 窗口：北京售票窗口
     2016-04-06 19:43:23.198 MutiThread[4762:1478201] 剩余票數：8 窗口：廣州售票窗口
     2016-04-06 19:43:23.404 MutiThread[4762:1478200] 剩余票數：7 窗口：北京售票窗口
     2016-04-06 19:43:23.609 MutiThread[4762:1478201] 剩余票數：6 窗口：廣州售票窗口
     2016-04-06 19:43:23.810 MutiThread[4762:1478200] 剩余票數：5 窗口：北京售票窗口
     2016-04-06 19:43:24.011 MutiThread[4762:1478201] 剩余票數：4 窗口：廣州售票窗口
     2016-04-06 19:43:24.216 MutiThread[4762:1478200] 剩余票數：3 窗口：北京售票窗口
     2016-04-06 19:43:24.422 MutiThread[4762:1478201] 剩余票數：2 窗口：廣州售票窗口
     2016-04-06 19:43:24.628 MutiThread[4762:1478200] 剩余票數：1 窗口：北京售票窗口
     2016-04-06 19:43:24.833 MutiThread[4762:1478201] 剩余票數：0 窗口：廣州售票窗口
     2016-04-06 19:43:25.039 MutiThread[4762:1478201] <NSThread: 0x7fe0d3c24360>{number = 3, name = 廣州售票窗口} Will Exit

　　可以看到，當票賣完後，兩個線程並沒有退出，仍在繼續運行，當到達指定時間後，線程2退出了，如果需要讓線程1退出，需要我們手動管理。

　　比如我們讓線程完成任務（售票）後自行退出，可以這樣操作

     - (void)saleTicket {
         while (1) {
             @synchronized(self) {
             //如果還有票，繼續售賣
                 if (_ticketCount > 0) {
                     _ticketCount --;
                     NSLog(@"%@", [NSString stringWithFormat:@"剩余票數：%ld 窗口：%@", _ticketCount, [NSThread currentThread].name]);
                     [NSThread sleepForTimeInterval:0.2];
                 }
                 //如果已賣完，關閉售票窗口
                 else {
                     if ([NSThread currentThread].isCancelled) {
                        break;
                     }else {
                        NSLog(@"售賣完畢");
                        //給當前線程標記為取消狀態
                        [[NSThread currentThread] cancel];
                        //停止當前線程的runLoop
                        CFRunLoopStop(CFRunLoopGetCurrent());
                     }
                 }
             }
         }
     }
     運行結果：
     2016-04-06 20:08:38.287 MutiThread[4927:1577193] 剩余票數：10 窗口：北京售票窗口
     2016-04-06 20:08:38.489 MutiThread[4927:1577194] 剩余票數：9 窗口：廣州售票窗口
     2016-04-06 20:08:38.690 MutiThread[4927:1577193] 剩余票數：8 窗口：北京售票窗口
     2016-04-06 20:08:38.892 MutiThread[4927:1577194] 剩余票數：7 窗口：廣州售票窗口
     2016-04-06 20:08:39.094 MutiThread[4927:1577193] 剩余票數：6 窗口：北京售票窗口
     2016-04-06 20:08:39.294 MutiThread[4927:1577194] 剩余票數：5 窗口：廣州售票窗口
     2016-04-06 20:08:39.499 MutiThread[4927:1577193] 剩余票數：4 窗口：北京售票窗口
     2016-04-06 20:08:39.700 MutiThread[4927:1577194] 剩余票數：3 窗口：廣州售票窗口
     2016-04-06 20:08:39.905 MutiThread[4927:1577193] 剩余票數：2 窗口：北京售票窗口
     2016-04-06 20:08:40.106 MutiThread[4927:1577194] 剩余票數：1 窗口：廣州售票窗口
     2016-04-06 20:08:40.312 MutiThread[4927:1577193] 剩余票數：0 窗口：北京售票窗口
     2016-04-06 20:08:40.516 MutiThread[4927:1577194] 售賣完畢
     2016-04-06 20:08:40.516 MutiThread[4927:1577193] 售賣完畢
     2016-04-06 20:08:40.517 MutiThread[4927:1577193] <NSThread: 0x7fb719d54000>{number = 2, name = 北京售票窗口} Will Exit
     2016-04-06 20:08:40.517 MutiThread[4927:1577194] <NSThread: 0x7fb719d552f0>{number = 3, name = 廣州售票窗口} Will Exit

　　如果確定兩個線程都是isCancelled狀態，可以調用[NSThread exit]方法來終止線程。

Next

　　接下來將更新GCD和NSOperation篇

16、iOS多線程篇：NSThread

相關推薦

16、iOS多線程篇：NSThread

val thread rec getc ive 同時 開放 orm 通信 一、什麽是NSThread 　　NSThread是基於線程使用，輕量級的多線程編程方法（相對GCD和NSOperation），一個NSThread對象代表一個線程，需要手動管理線程的生命周期，處理線

iOS多執行緒篇：NSThread簡單介紹和使用

一、什麼是NSThread NSThread是基於執行緒使用，輕量級的多執行緒程式設計方法（相對GCD和NSOperation），一個NSThread物件代表一個執行緒， 需要手動管理執行緒的生命週期

iOS多執行緒篇：NSThread

原文 一、什麼是NSThread NSThread是基於執行緒使用，輕量級的多執行緒程式設計方法（相對GCD和NSOperation），一個NSThread物件代表一個執行緒，需要手動管理執行緒的生命週期，處理執行緒同步等問題。 二、NSThread

iOS多線程開發之離不開的GCD（上篇）

sop 先進先出 調度 事件 實現 說明 優先級 子線程 函數 一、GCD基本概念 GCD 全稱Grand Central Dispatch(大中樞隊列調度)，是一套低層API,提供了?種新的方法來進?並發程序編寫。從基本功能上講，GCD有點像NSOperatio

iOS開發多線程篇—創建線程

ati 直接 lec 後臺線程 代碼 btn amp self 設置 一、創建和啟動線程簡單說明 一個NSThread對象就代表一條線程 創建、啟動線程 (1) NSThread *thread = [[NSThread alloc] initWithTarget:sel

iOS開發多線程篇—GCD的基本使用

@property 函數 特殊 sig 屏幕 select 獲取 nba ike 一、主隊列介紹 主隊列：是和主線程相關聯的隊列，主隊列是GCD自帶的一種特殊的串行隊列，放在主隊列中得任務，都會放到主線程中執行。 提示：如果把任務放到主隊列中進行處理，那

iOS開發多線程篇—自定義NSOperation

一個 gate operation cti reserve RKE 新建 工廠 oar 一、實現一個簡單的tableView顯示效果 實現效果展示： 代碼示例（使用以前在主控制器中進行業務處理的方式） 1.新建一個項目，讓控制器繼承自UITableViewContro

iOS開發多線程篇—線程安全

object -- nss property 處理 壓力 nat 安全問題 加鎖 一、多線程的安全隱患 資源共享 1塊資源可能會被多個線程共享，也就是多個線程可能會訪問同一塊資源 比如多個線程訪問同一個對象、同一個變量、同一個文件 當多個線程訪問同一塊資源時，很容易引發數據

iOS 多線程：『RunLoop』詳盡總結

after 添加 src 睡眠狀態 刷新 翻譯 每一個 don 1.2 1. RunLoop 簡介 1.1 什麽是 RunLoop？ 可以理解為字面意思：Run 表示運行，Loop 表示循環。結合在一起就是運行的循環的意思。哈哈，我更願意翻譯為『跑圈』。直觀理解就像

多線程學習：Volatile與Synchronized的區別、什麽是重排序

art 不可 順序 經典的 排序 傳遞 -s style family java線程的內存模型 　　java的線程內存模型中定義了每個線程都有一份自己的共享變量副本（本地內存），裏面存放自己私有的數據，其他線程不能直接訪問，而一些共享變量則存在主內存中，供所有線

ios多線程操作（四）—— GCD核心概念

indent img 操作 fort 16px 2.0 b2c 有一種 read GCD全稱Grand Central Dispatch。可譯為“大派發中樞調度器”，以純C語言寫成，提供了很多很強大的函數。GCD是蘋果公司為多核的並行運算提出的解決方式，它能夠自己主

iOS多線程---GCD中線程的通信

獲取 bsp blog global col object ios多線程 nts load 在子線程的任務完成後，有時候需要從子線程回到主線程，刷新UI。 從子線程中回到主線程，以前已經寫過一種方法： [self.imageView performSelectorO

iOS多線程---NSOperation介紹和使用

star cati log 對象 sop exec 使用 sin 方式 1. NSOperation實現多線程編程，需要和NSOperationQueue一起使用。 （1）先將要執行的操作封裝到NSOperation中 （2）將NSOperation對象添加到NSOper

iOS多線程---NSOperation的常用操作

自動 最大並發數 com str 需要 循環 單個 監聽 sin 1.最大並發數： - (NSInteger)maxConcurrentOperationCount;- (void)setMaxConcurrentOperationCount:(NSInteger)cnt;

iOS多線程開發之GCD（下篇）

num 不能 每次 自定義 left void 類型 c函數 current 上篇和中篇講解了什麽是GCD，如何使用GCD，這篇文章將講解使用GCD中將遇到的死鎖問題。有興趣的朋友可以回顧《iOS多線程開發之GCD（上篇）》和《iOS多線程開發之GCD（中篇）》。

iOS多線程開發之NSOperation - 快上車，沒時間解釋了！

ddt null sleep main set ask 多個 ops exec 一、什麽是NSOperation？ NSOperation是蘋果提供的一套多線程解決方案。實際上NSOperation是基於GCD更高一層的封裝，但是比GCD更加的面向對象、代碼可讀

ios 多線程

eight 類方法 c語法 ria create method 同步 關系 shared 轉自：http://www.maxiaoguo.com/clothes/254.html 多線程包含：GCD NSOperation NSOperation是在GCD語

iOS 多線程,ARC

log found evel ios 多線程 自動釋放 釋放 無法 -c 線程 iOS自己創建的線程需要自己定時的創建autorelease pools，否則對象不能及時自動釋放。 方法1是不對的，while中的對象會無法及時釋放。 1:-(void)Thread{

iOS多線程方案總結及使用詳解

alloc www nop 線程狀態 efault div elf don ddd 本篇文章整理了幾種iOS中主要的多線程方案，提供了Swift和Objective-C兩種語言的寫法。 概述 iOS目前有四種多線程解決方案： NSThread GCD NSOperatio

iOS多線程編程--NSOperation（轉）

https 同時 寫到 elf 調整 ber ios多線程 bool per 這篇文章寫得非常不錯，基礎用法都涉及到了，我把文章提到的例子都寫到了demo裏面， 原文地址： iOS多線程--徹底學會多線程之『NSOperation』 demo下載：https://githu