kkbox-ios-dev笔记(七) - Threading

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 

@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