Threading

Perform Selector

-performSelectorOnMainThread: withObject: waitUntilDone: modes:
-performSelectorOnMainThread: withObject: waitUntilDone:

-performSelector: onThread: withObject: waitUntilDone: modes:
-performSelector: onThread: withObject: waitUntilDone:
-performSelectorInBackground: withObject:

* 無法管理應該要創建多少個子線程，才達到其硬件性能的上限。
* 如果要在子線程上調用了一個方法，這個方法里面必須要有自己的緩沖池，才能正確釋放對象。要建立緩沖池，在 ARC 模式下，可以使用`@autoreleasepool`關鍵字。（針對該方式）

```swift
- (void)backgroundTask

{
@autoreleasepool {
// Write your code here.
}
}

####GCD Grand Central Dispatch 
**dispatch_async**

>* 選擇要在哪個指定的線程上，用非同步的方式執行一個 `block`。
>
>```swift
>dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY

_DEFAULT, 0), ^{
[someObject doSomethingHere];
});

* `dispatch_get_global_queue`這個方法會讓系統根據目前的狀況，在恰當的時機建立一個子線程，第一個參數是這個線程執行工作的優先程度，從 2 到 -2，2 為最重要，-2 為最不重要。至于第二個參數則是保留參數，目前沒有，直接填 0 即可。
* 如果已經在子線程，想要在主線程執行任務，就把`dispatch_get_global_queue`換成`dispatch_get_main_queue`。

```swift
dispatch_async(dispatch_get_main_queue(), ^{

[someObject doSomethingHere];

});

* 組合兩者調用

```swift
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY

_DEFAULT, 0), ^{
[someObject doSomethingInBackground];
dispatch_async(dispatch_get_main_queue(), ^{
[someObject doSomethingOnMainThread];
});
});

* 在子線程，事件保持串行隊列執行

```swift
dispatch_queue_t serialQueue = dispatch_queue_create("com.kkbox.queue", DISPATCH_QUEUE_SERI

AL);
dispatch_async(serialQueue, ^{
[someObject doSomethingHere];
});
dispatch_async(serialQueue, ^{
[someObject doSomethingHereAsWell];
});

• dispatch_sync

• 注意：已經在一條線程中，調用dispatch_sync時所傳入的線程就是目前所在的線程，就會造成程序執行時卡死。如在主線程，但我們卻調用：

dispatch_sync(dispatch_get_main_queue(), ^{

[someObject doSomethingHere];

});

• 其他一些好用的 API
• dispatch_once
• dispatch_after
• dispatch_apply
• 想要重復執行某個block，就可以考慮使用。有三個參數：第一個表示執行的次數，第二個表示執行的方式。

NSOpertation與NSOperationQueue

• 可以中途取消某個線程
• GCD 只支持 FIFO 的隊列， 而NSOperationQueue可以調整隊列的執行順序。（通過調整權重）
• NSOperationQueue可以在Operation間設置依賴關系，而 GCD 不可以。
• NSOperationQueue是在 GCD 基礎上實現的，只不過是 GCD 更高一層的抽象。

建立 NSOperationQueue

#import <Foundation/Foundation.h>

@interface Test : NSObject
@property (nonatomic, strong) NSOperationQueue *queue;
@end
@implementation Test

• (instancetype)init
  {
  self = [super init];
  if (self) {
  self.queue = [[NSOperationQueue alloc] init];
  self.queue.maxConcurrentOperationCount = 2;
  }
  return self;
  }
  @end

* 通過`maxConcurrentOperationCount`設置可以并發執行的個數。該值大于 1，表示可以并發執行，如果等于 1，表示依次執行，等于 0 則不執行任務，默認 -1，表示讓系統自己決定應該同時建立多少個子線程。
* 可以通過對`NSOperationQueue`調用`addOperation:`加入操作。用`cancelAllOperations`取消所有正在線程排隊執行的操作。至于已經在執行的操作，我們可以對特定的操作調用`cancel`。

####建立 NSOperation
* 包含兩個`NSOperation`的子類：`NSBlockOperation`與`NSInvocationOperation`.
* 要自定義一個`NSOperation`,最重要的就是要重寫`main`這個方法，該方法里面代表的是這個操作要做什么事情

```swift
@interface RecipetUploadOperation : NSOperation

@property (nonatomic, strong) UIImage *image;
@property (nonatomic, strong) NSString *JSON;
@end
@implementation RecipetUploadOperation

• (void)main
  {
  @autoreleasepool {
  // 1. Upload image
  // 2. Upload JSON
  }
  }
  @end

* 在 `main` 里面也要建立緩存池。

####在Operation中等待與取消
* **NSRunloop**
* 除了主線程的`runloop`外（`[NSRunloop mainRunLoop]`），每一個線程都有自己的`runloop`，只要調用`[NSRunloop currentRunLoop]`便可以拿到當前線程的`runloop`。`NSRunloop`不可以手動建立，只能使用系統提供的。
* 在`operation`執行到一半的時候可以被取消，調用`cancel`方法即可。如果是`operation`的子類，改變了`operation`里面做的事情。那么就得重寫`cancel`:當該`operation`在跑`runloop`時，`cancel`必須要能夠通知`runloop`停止。
* 當一個線程跑在自己的`runloop`內時。如果不同線程間需要相互通信，就必須在當前線程建立`NSPort`對象，注冊到`runloop`內，才能讓信息傳入到`runloop`內。所以，當外部要求對`port`調用`invalidate`時，就會讓`runloop`收到消息，停止繼續執行，繼續執行`- main`方法接下來的動作。

```swift
@interface RecipetUploadOperation : NSOperation

{
NSPort *port;
BOOL runloopRunning;
}
@property (nonatomic, strong) UIImage *image;
@property (nonatomic, strong) NSString *JSON;
@end
@implementation RecipetUploadOperation

• (void)main
  {
  @autoreleasepool {
  [someAPI uploadImageData:UIImagePNGRepresentation(self.i
  mage) callback:^ {
  [self quitRunLoop];
  }];
  [self doRunloop];
  if (self.isCancelled) {
  return;
  }
  [someAPI uploadJSON:self.JSON callback:^ {
  [self quitRunLoop];
  }];
  [self doRunloop];
  }
  }
• (void)doRunloop
  {
  runloopRunning = YES;
  port = [[NSPort alloc] init];
  [[NSRunLoop currentRunLoop] addPort:port forMode:NSRunLoopCo
  mmonModes];
  while (runloopRunning && !self.isCancelled) {
  @autoreleasepool {
  [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dat
  eWithTimeIntervalSinceNow:0.5]];
  }
  }
  port = nil;
  }
• (void)quitRunLoop
  {
  [port invalidate];
  runloopRunning = NO;
  }
• (void)cancel
  {
  [super cancel];
  [self quitRunLoop];
  }
  @end

* **GCD**
* 當我們想要在執行到一半的時候暫停下來，現在可以建立`semaphore`對象。
 * 在要對`semaphore`調用`dispatch_semaphore_wait`,程序就會在這個地方停止等候。
對已經等候中的`semaphore`，再調用`dispatch_semaphore_signal`,發送`signal`，程序就會繼續往下執行。

```swift
@import UIKit;

@interface RecipetUploadOperation : NSOperation
@property (nonatomic, strong) UIImage *image;
@property (nonatomic, strong) NSString *JSON;
@property (nonatomic, strong) dispatch_semaphore_t semaphore;
@end
@implementation RecipetUploadOperation

• (void)main
  {
  @autoreleasepool {
  self.semaphore = dispatch_semaphore_create(0);
  [someAPI uploadImageData:UIImagePNGRepresentation(self.i
  mage) callback:^ {
  dispatch_semaphore_signal(self.semaphore);
  }];
  dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FO
  REVER);
  if (self.cancelled) {
  return;
  }
  self.semaphore = dispatch_semaphore_create(0);
  [someAPI uploadJSON:self.JSON callback:^ {
  dispatch_semaphore_signal(self.semaphore);
  }];
  dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FO
  REVER);
  } }
• (void)cancel
  {
  [super cancel];
  dispatch_semaphore_signal(self.semaphore);
  }
  @end