IOS多线程编程简介
基本概念
线程： 线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。线程是独立调度和分派的基本单位。同一进程中的多条线程将共享该进程中的全部系统资源，但是自有调用堆栈和寄存器环境。
进程： 进程是计算机中已运行程序的实体。其本身并不是几部运行单位，是线程的容器。
任务： 任务(task)用于指代抽象的概念,表示需要执行工作，具体可以是一个函数或者一个block。
关于进程和线程的描述推荐《进程与线程的一个简单解释》,浅显易懂。
IOS常用的多线程编程技术
IOS常用的多线程编程技术包括：NSThread、Cocoa NSOperation、GCD（grand central dispatch）。其优缺点对比如下表所示：
| 多线程技术 | 优点 | 缺点 |
|---|---|---|
| NSThread | 轻量级最低，相对简单 | 需要手动管理所有的线程活动（生命周期，休眠，同步等）线程同步对数据的加锁会有一定的系统开销 |
| Cocoa NSOperation | 自带线程周期管理，可只关注自己处理逻辑 | NSOperation是面向对象的抽象类，实现只能是其子类（NSInvocationOperation和NSBlockOperation），对象需要添加到NSOperationQueue队列里执行 |
| GCD | 效率高，可避免并发陷阱 | 基于C而非OC实现 |
如果对性能效率要求较高，处理大量并发时用GCD，简单而安全的可用NSOPeration或者NSThread。Apple推荐使用GCD
NSThread
NSThread具体的底层实现机制是Mach线程，实现技术有三种Cocoa threads、POSIX threads（UNIX）、Multiprocessing Services。
使用方式
- 显式创建方式：
-(id)initWithTarget:(id)target selector:(SEL)selector object:(id)argument
+(void)detachNewThreadSelector:(SEL)aSelector toTarget:(id)aTarget withObject:(id)anArgument
- 隐式创建方式：
[Object performSelectorInBackground:@selector(doSomething)withObject:nil];
代码示例
- (void)testNSThread{
_lock = [[NSLock alloc] init];
_condition = [[NSCondition alloc] init];
self.total = 20;
NSThread *thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
[thread1 setName:@"Thread--1"];
[thread1 start];
NSThread *thread2 = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
[thread2 setName:@"Thread--2"];
[thread2 start];
// [NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];
// [self performSelectorInBackground:@selector(run) withObject:nil];
}
- (void)run{
while (YES) {
[self.lock lock];
if(self.total >= 0){
[NSThread sleepForTimeInterval:0.09];
NSInteger count = 20 - self.total;
NSLog(@"total is :%zd,left is:%zd, thread name is:%@", self.total, count,[[NSThread currentThread] name]);
self.total--;
}else{
break;
}
[self.lock unlock];
}
}
分析说明：
NSThread中线程内存管理，是否循环引用，同步问题都需要手动管理。除了代码中的lock还可以用@synchronized来简化NSLock的使用。
- (void)doSomeThing:(id)anObj
{
@synchronized(anObj)
{
// Everything between the braces is protected by the @synchronized directive.
}
}
还可以用NSCondition中的wait消息设置等待线程，然后通过signal消息 发送信号的方式，在一个线程唤醒另外一个线程的等待。
线程间通信：
//在指定线程上执行操作
//在主线程上执行操作
[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:YES];
[self performSelector:@selector(run) onThread:threadName withObject:nil waitUntilDone:YES];
//在当前线程执行操作
[self performSelector:@selector(run) withObject:nil];
获取线程：
NSThread *current = [NSThread currentThread];
NSThread *main = [NSThread mainThread];
Cocoa NSOperation
使用方式
NSOperation的使用方式有两种：
- 使用NSInvocationOperation和NSBlockOperation
- 自定义NSOperation子类。
代码示例
-(void)testNSOPeration{
self.total = 20;
NSInvocationOperation *operation1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run2) object:nil];
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:operation1];
NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
[self run2];
}];
// [operation1 start];//当前线程直接执行
[operation2 addDependency:operation1];
// [operation2 addExecutionBlock:^{
// [self run];
// }];
[queue addOperation:operation2];
// queue.maxConcurrentOperationCount = 1;
}
- (void)run2{
while (YES) {
if(self.total >= 0){
// [NSThread sleepForTimeInterval:0.09];
NSInteger count = 20 - self.total;
NSLog(@"total is :%zd,left is:%zd, thread name is:%@", self.total, count,[[NSThread currentThread] name]);
self.total--;
}else{
break;
}
}
}
自定义NSOperation子类
自定义NSOperation子类需要实现start、main、isExecuting、isFinish、isConcurrnet（asynchronous）方法。
@interface MyOperation : NSOperation {
BOOL executing;
BOOL finished;
}
- (void)completeOperation;
@end
@implementation MyOperation
- (id)init {
self = [super init];
if (self) {
executing = NO;
finished = NO;
}
return self;
}
- (BOOL)isConcurrent {
return YES;
}
- (BOOL)isExecuting {
return executing;
}
- (BOOL)isFinished {
return finished;
}
@end
分析说明
NSOperationQueue 是一个并行队列，可以通过设置maxConcurrentOperationCount来设定最大并行操作数，对于自定义实现的NSOperation子类，可以通过实现isConcurrent(isAsynchronous)方法来制定具体的操作是否同步执行。
GCD
使用方式
GCD的工作原理是让程序平行排队的特定任务，根据可用的处理资源，安排他们在任何可用的处理器核心上执行任务。
队列的创建
- 主线程队列（串行）：
dispatch_get_main_queue() - 全局队列（并行）：
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
第一个参数说明队列的优先级，第二个参数暂未用到，默认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
- 自定义队列：
dispatch_queue_create(queuename, attr)
第一个参数制定队列名称，自定义队列可以是串行也可以是并行的，由第二个参数attr决定。
DISPATCH_QUEUE_SERIAL //(NULL) 串行
DISPATCH_QUEUE_SERIAL_INACTIVE
DISPATCH_QUEUE_CONCURRENT //并行
多线程执行
- 同步执行：
dispatch_sync(dispatch_queue_t _Nonnull queue, ^(void)block) - 异步执行：
dispatch_async(dispatch_queue_t _Nonnull queue, ^(void)block) - 一次性执行：
tatic dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ code to be executed once });
- 延时执行：
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ code to be executed after a specified delay });
- 循环迭代执行：
dispatch_apply(size_t iterations, dispatch_queue_t _Nonnull queue, ^(size_t)block)
能并发地执行不同的迭代。这个函数是同步的，所以和普通的 for 循环一样，它只会在所有工作都完成后才会返回。 - 栅栏(barrier)执行：
dispatch_barrier_sync(dispatch_queue_t _Nonnull queue, ^(void)block) dispatch_barrier_async(dispatch_queue_t _Nonnull queue, ^(void)block)
栅栏执行的意思是：在barrier前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行。 - 分组执行：
dispatch_group_async(dispatch_group_t _Nonnull group, dispatch_queue_t _Nonnull queue, ^(void)block) dispatch_group_notify(dispatch_group_t _Nonnull group, dispatch_queue_t _Nonnull queue, ^(void)block)
dispatch_group_async可以实现监听一组任务是否完成，完成后得到通知执行其他的操作
信号量
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
dispatch_semaphore_signal(semaphore);
dispatch_time_t timeoutTime = dispatch_time(DISPATCH_TIME_NOW, kDefaultTimeoutLengthInNanoSeconds); dispatch_semaphore_wait(semaphore, timeoutTime)
Dispatch Source
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatchQueue);
dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, intervalInSeconds * NSEC_PER_SEC, leewayInSeconds * NSEC_PER_SEC);
dispatch_source_set_event_handler(timer, ^{
code to be executed when timer fires
});
dispatch_resume(timer);
代码示例
栅栏执行：
- (void)testBarrier{
dispatch_queue_t queue = dispatch_queue_create("com.zyw.test", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:1];
NSLog(@"dispatch_async1");
});
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:2];
NSLog(@"dispatch_async2");
});
dispatch_barrier_async(queue, ^{
NSLog(@"dispatch_barrier_async");
[NSThread sleepForTimeInterval:2];
});
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:1];
NSLog(@"dispatch_async3");
});
}
输出：
2016-12-02 17:17:24.710 TestThread[1434:164682] dispatch_async1
2016-12-02 17:17:25.713 TestThread[1434:164681] dispatch_async2
2016-12-02 17:17:25.713 TestThread[1434:164681] dispatch_barrier_async
2016-12-02 17:17:28.720 TestThread[1434:164681] dispatch_async3
分组执行：
- (void)testGroup{
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{
[NSThread sleepForTimeInterval:1];
NSLog(@"group1");
});
dispatch_group_async(group, queue, ^{
[NSThread sleepForTimeInterval:2];
NSLog(@"group2");
});
dispatch_group_async(group, queue, ^{
[NSThread sleepForTimeInterval:3];
NSLog(@"group3");
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"EndAllgroupTask");
});
// 第二种使用方法
// dispatch_group_enter(group);
// dispatch_group_leave(group);
// dispatch_group_notify(group, dispatch_get_main_queue(), ^{
//
// });
}
输出：
2016-12-02 17:11:50.592 TestThread[1407:161853] group1
2016-12-02 17:11:51.591 TestThread[1407:161852] group2
2016-12-02 17:11:52.589 TestThread[1407:161855] group3
2016-12-02 17:11:52.590 TestThread[1407:161635] EndAllgroupTask
信号量：
- (void)testSemaphore{
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_semaphore_t semaphore = dispatch_semaphore_create(5);
for (NSInteger i = 0 ; i < 10; i++) {
dispatch_async(queue, ^{
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
NSLog(@"*****%zd", i);
[NSThread sleepForTimeInterval:1];
dispatch_semaphore_signal(semaphore);
});
}
}
输出：
2016-12-02 17:36:11.071 TestThread[1496:173204] *****1
2016-12-02 17:36:11.071 TestThread[1496:173207] *****2
2016-12-02 17:36:11.071 TestThread[1496:173203] *****0
2016-12-02 17:36:11.071 TestThread[1496:173242] *****3
2016-12-02 17:36:11.071 TestThread[1496:173243] *****4
2016-12-02 17:36:12.074 TestThread[1496:173244] *****5
2016-12-02 17:36:12.074 TestThread[1496:173250] *****9
2016-12-02 17:36:12.074 TestThread[1496:173246] *****7
2016-12-02 17:36:12.074 TestThread[1496:173245] *****6
2016-12-02 17:36:12.074 TestThread[1496:173247] *****8
Dispatch Source
- (void)testSource{
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
dispatch_time_t start = dispatch_time(DISPATCH_TIME_NOW, 5);
dispatch_source_set_timer(timer, start, 3 * NSEC_PER_SEC, 0 * NSEC_PER_SEC);
dispatch_source_set_event_handler(timer, ^{
NSLog(@"******Hello");
});
//启动
dispatch_resume(timer);
}
同步异步串行并行简单常用未列出
分析说明
同步异步和并行串行
| 并行队列 | 串行队列 | 主队列 | |
|---|---|---|---|
| 异步执行 | 开启多个新的线程，任务同时执行 | 开启一个新的线程，任务按顺序执行 | 不开启新的线程，任务按顺序执行 |
| 同步执行 | 不开启新的线程，任务按顺序执行 | 不开启新的线程,任务按顺序执行 | 死锁 |
对于GCD中的block执行，都有对应的function执行函数，比如：
dispatch_sync_f(dispatch_queue_t _Nonnull queue, void * _Nullable context, dispatch_function_t _Nonnull work)
dispatch_async_f(dispatch_queue_t _Nonnull queue, void * _Nullable context, dispatch_function_t _Nonnull work)
信号量
dispatch_semaphore_create(N);N>=0时可以正常执行，当N小于0时一直等待
代码示例的解释：创建了一个初使值为5的semaphore，每一次for循环都会创建一个新的线程（具体看GCD的线程池，此处认为是新建），线程结束的时候会发送一个信号，线程创建之前会信号等待，所以当同时创建了5个线程之后，for循环就会阻塞，等待有线程结束之后会增加一个信号才继续执行，如此就形成了对并发的控制，如上就是一个并发数为5的一个线程队列。
Dispatch Source
它基本上就是一个低级函数的 grab-bag，可监听事件如下：
DISPATCH_SOURCE_TYPE_DATA_ADD：属于自定义事件，可以通过dispatch_source_get_data函数获取事件变量数据，在我们自定义的方法中可以调用dispatch_source_merge_data函数向Dispatch Source设置数据，下文中会有详细的演示。
DISPATCH_SOURCE_TYPE_DATA_OR：属于自定义事件，用法同上面的类型一样。
DISPATCH_SOURCE_TYPE_MACH_SEND：Mach端口发送事件。
DISPATCH_SOURCE_TYPE_MACH_RECV：Mach端口接收事件。
DISPATCH_SOURCE_TYPE_PROC：与进程相关的事件。
DISPATCH_SOURCE_TYPE_READ：读文件事件。
DISPATCH_SOURCE_TYPE_WRITE：写文件事件。
DISPATCH_SOURCE_TYPE_VNODE：文件属性更改事件。
DISPATCH_SOURCE_TYPE_SIGNAL：接收信号事件。
DISPATCH_SOURCE_TYPE_TIMER：定时器事件。
DISPATCH_SOURCE_TYPE_MEMORYPRESSURE：内存压力事件。
