IOS三种线程技术各自优缺点
大家都知道，多线程提（多核心）高了计算机的处理速度。我对这一块有浅浅的认识，跟大家分享：
首先 大家要注意 1 、线程的使用不是无节制的 2、只有主线程有直接修改UI的能力。
IOS的三种多线程技术：
一 、NSThread 是每个NSThread对象对应一个线程，轻量级的。是对pthread（其是POSIX线程的API，是C语言的技术，当 然它可以直接操作线程）的抽象。
二、 GCD（Grand Central Dispatch）是基于C语言的框架，使用队列来管理线程，它可以充分利用多核。
三、NSOperation/NSOperationQueue是面向对象的线程技术，是对GCD的抽象，容易理解和使用。
三种线程的对比
NSThread 、 优点：使用特别简单。
缺点：需要自己来管理线程的生命周期、线程同步、加锁、睡眠和唤醒。过程不可避免的有一定的系统“开销”；
NSOperation、优点：不用关心线程的管理和数据的同步，把精力放在自己需要执行的任务或操作上就行了
而且它是面向对象的；
GCD、 优点：Grand Central Dispatch是由苹果公司开发的一个多核编程解决方案。IOS4.0以后才能使用，是代替上面两个技 术的高效而且强大的技术。它基于block的特性导致它能极为简单的在不同代码作用域之间传递上下文。效率高。性能： GCD自动根据系统负载来增减线程数量，这就减少了上下文的切换和提高了计算效率。安全 无需加锁或其他同步机制。（看起来就很高大上嘛。）
它是基于C语言的；
NSThread 创建与启动
//第1种 调用mutableThread方法
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(mutableThread) object:nil];
[thread start];
//第2种 调用mutableThread方法
[NSThread detachNewThreadSelector:@selector(mutableThread) toTarget:self withObject:nil];
//第3种 调用mutableThread方法
[self performSelectorInBackground:@selector(mutableThread) withObject:nil];
<span style="font-size: 14px;">NSThread 的常用方法</span>
//获取当前线程对象 +(NSThread *)currentThread; //判断当前线程是否为主线程 +(BOOL)isMainThread; //使当前线程睡眠指定的时间 单位 S +(void)sleepForTimeInterval:(NSTimeInterval)timeMiao; //退出当前线程 +(void)exit; //启动该线程 - (void)start;注意：NSThread 可以直接使用线程，但是当你的代码和框架中都创建自己的线程时，那么活动线程会指数增长，虽然每块没有问题，但是结果就导致问题。而且使用线程会消耗一些内存和内核资源
线程队列NSOperationQueue
//1 block
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperationWithBlock:^{
NSThread *thread = [NSThread currentThread];
if (![thread isMainThread]) {
NSLog(@"这是个多线程");
}
}];
//2 NSOPeration 开启一个线程
NSOperationQueue *threadQueue = [[NSOperationQueue alloc] init];
NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(mutableThread) object:nil];
[threadQueue addOperation:op];
//3在主线程上调用reloadData方法
[self performSelectorOnMainThread:@selector(reloadData) withObject:nil waitUntilDone:NO];
GCD:
Dispatch Queue
Dispatch Queue 是执行处理的等待队列。通过dispatch_async等函数，按照先进先出顺序追加到Queue中处理
处理的时候Dispatch Queue有两种
1.Serial Dispatch Queue 等待现在正在执行的任务处理结束（串行）
2.Concurrent Dispatch Queue 不等带现在正在执行的任务的任务处理结束（并行、并发）
//1.
//定义想要执行的操作（任务），追加到适当的队列中(Dispatch Queue)
//GCD简单用法
/*
dispatch_async(queue, ^{
;
});
*/
//(1)追加的队列
//(2)block 要执行的任务
//2.Queue类型
//(1)Serial Dispatch Queue --- 等待现在正在执行的任务处理结束（串行）
//(2)Concurrent Dispatch Queue --- 不等待现在正在执行的任务处理结束（并行、并发）
//3.自己定义queue，把任务加到自定义的queue之中
/*
//(1)创建queue
//第一个参数:给队列起名字
//第二个参数:queue的类型 (默认是串行的)
dispatch_queue_t queue1 = dispatch_queue_create("com.wxhl.gcd.Queue1", NULL);
dispatch_queue_t queue2 = dispatch_queue_create("com.wxhl.gcd.Queue2", DISPATCH_QUEUE_CONCURRENT); //并行的queue
//(2)创建要执行的任务，加到queue中执行
dispatch_async(queue2, ^{
for (int i = 0; i < 50; i ++) {
NSLog(@"GCD : %d", i);
}
});
dispatch_async(queue2, ^{
for (int i = 0; i < 50; i ++) {
NSLog(@"GCD2------ : %d", i);
}
});
//ARC会自动管理内存
// dispatch_release(queue1);
// dispatch_retain(queue1);
*/
Dispatch After:
//Dispatch After
//一段时间之后，把要执行的任务追加到队列当中
//创建时间
//相对的时间点 相对第一个参数多长时间之后
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3ull * NSEC_PER_SEC);
//时间的单位
//NSEC_PER_SEC 秒
//NSEC_PER_MSEC 毫秒
//NSEC_PER_USEC 微秒
//dispatch_time_t 指定的时间
dispatch_after(time, dispatch_get_main_queue(), ^{
NSLog(@"after 3s");
});
//第二种用法
dispatch_after_f(dispatch_time(DISPATCH_TIME_NOW, 3ull * NSEC_PER_SEC), dispatch_get_main_queue(), NULL, func1);
//自己使用
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5ull * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
;
});
#warning 注意
//1.不是一段时间之后执行相应的任务 （而是把要执行的任务追加到队列当中）
//2.主线程 runloop 1/60秒检测事件, 追加的时间范围 3s - (3 + 1/60)s
dispatch group:
(它的第二种监测方法是通过时间 去检测（比如5秒），但是它只是在5秒后去看一次，没有执行完和执行完 做出的响应分为两个。我还没有发现这个方法的应用实例，我做的项目非常少，可能以后会用上，也很简单)
//并行队列执行任务, 多个串行的队列
//dispatch group
//1.创建 group
dispatch_group_t group = dispatch_group_create();
//2.获取队列
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
//3.使用 group 监视 队列任务的执行
dispatch_group_async(group, queue, ^{
NSLog(@"task 1");
});
dispatch_group_async(group, queue, ^{
NSLog(@"task 2");
});
dispatch_group_async(group, queue, ^{
NSLog(@"task 3");
});
dispatch_group_async(group, queue, ^{
sleep(6);
NSLog(@"task 4");
});
//(1)监视的函数
//监视到队列里任务执行结束，执行block里面的任务
dispatch_group_notify(group, queue, ^{
//结束处理
NSLog(@"done");
});
dispatch sync/dispatch async dispatch sync 容易遇见死锁问题，一般熟练者用（我不行）
//dispatch sync
//
//async: asynchronous 将任务异步的追加到队列中
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"async");
});
//sync: synchronous 将任务同步的追加到队列中(等队列中的任务执行完，再将任务追加到队列)
//是同步追加，不是任务同步执行，在串行队列中，任务才同步执行
dispatch_sync(dispatch_get_global_queue(0, 0), ^{
NSLog(@"sync");
});
//dispatch_sync的问题：容易产生死锁
//示例1:
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"hello");
});
NSLog(@"主线程");
//上述代码在主队列中执行指定的block，等待其执行结束
//而主队列中本来就在执行上述代码，无法执行追加的block
//示例2:
//串行的队列
dispatch_queue_t queue = dispatch_queue_create("com.wxhl.GCD.queue", NULL);
dispatch_async(queue, ^{
dispatch_sync(queue, ^{
NSLog(@"串行队列");
});
});
<span style="font-size:24px;">Dispatch Semaphore</span>
//Dispatch Semaphore
//持有计数的信号
//1.计数为0时，等待
//2.计数大于等于1时，减去1，而且不等待
//使用
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
dispatch_semaphore_t dsema = dispatch_semaphore_create(1);
NSMutableArray *array = [NSMutableArray array];
for (int i = 0; i < 1000; i++) {
dispatch_async(queue, ^{
dispatch_semaphore_wait(dsema, DISPATCH_TIME_FOREVER);
[array addObject:[NSNumber numberWithInt:i]];
dispatch_semaphore_signal(dsema);
});
}