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_oncedispatch_afterdispatch_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
