通过NSThread类开辟子线程
- (IBAction)handleThread:(id)sender {
// 创建线程对象.
NSThread *thread1 = [[NSThread alloc]initWithTarget:self selector:@selector(handleFun:) object:nil];
thread1.name = @"sum";
// 手动开启
[thread1 start];
// 创建线程对象自动开启
[NSThread detachNewThreadSelector:@selector(handleFun:) toTarget:self withObject:nil];
//取消线程
[thread1 cancel];
}
除了创建启动外，NSThread 还以很多方法，下面我列举一些常见的方法，当然我列举的并不完整，更多方法大家可以去类的定义里去看。
//取消线程
- (void)cancel;
//启动线程
- (void)start;
//判断某个线程的状态的属性
@property (readonly, getter=isExecuting) BOOL executing;
@property (readonly, getter=isFinished) BOOL finished;
@property (readonly, getter=isCancelled) BOOL cancelled;
//设置和获取线程名字
-(void)setName:(NSString *)n;
-(NSString *)name;
//获取当前线程信息
+ (NSThread *)currentThread;
//获取主线程信息
+ (NSThread *)mainThread;
//使当前线程暂停一段时间，或者暂停到某个时刻
+ (void)sleepForTimeInterval:(NSTimeInterval)time;
+ (void)sleepUntilDate:(NSDate *)date;
通过NSOperationQueue "开辟子线程"
Queue(队列)中是NSOperation对象.
一个NSOperation对象就是一个任务(一段功能代码),本身和线程没有关系(不能开子线程).
NSOperation 只是一个抽象类，所以不能封装任务。但它有 2 个子类用于封装任务。分别是：NSInvocationOperation 和 NSBlockOperation 。创建一个 Operation 后，需要调用 start 方法来启动任务，它会默认在当前队列同步执行。当然你也可以在中途取消一个任务，只需要调用其 cancel 方法即可。
NSOperation 和 NSOperationQueue 分别对应 GCD 的 任务 和 队列
- (IBAction)handleOperationQueue:(id)sender {
// NSInvocationOperation 创建对象(多个)
NSInvocationOperation *invocation = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(handleFun:) object:nil];
NSInvocationOperation *invocation2 = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(handleFun:) object:nil];
// NSBlockOperation 创建任务
__weak typeof(self)weakSelf = self;
NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
[weakSelf handleFun:nil];
}];
// 创建 operationQueue 队列
NSOperationQueue *queue = [[NSOperationQueue alloc]init];
//NSOperationQueue 有一个参数 maxConcurrentOperationCount 最大并发数，用来设置最多可以让多少个任务同时执行。当你把它设置为 1 的时候，变为串行队列！
queue.maxConcurrentOperationCount = 1;
[queue addOperation:invocation];
[queue addOperation:invocation2];
[queue addOperation:blockOperation];
//开启
[invocation start];
[blockOperation start];
}
GCD开启子线程
在 GCD 中，加入了两个非常重要的概念： 任务 和 队列。
任务：即操作，你想要干什么，说白了就是一段代码，在 GCD 中就是一个 Block，所以添加任务十分方便。任务有两种执行方式： 同步执行 和 异步执行，他们之间的区别是 是否会创建新的线程。
/**
- GCD 核心: 队列和任务
- 队列: 串行队列和并行队列.
- 任务: block块 和 函数
- 程序本身有一个串行队列(主线程).
- 有4个并行队列(优先级区别).
- 自定义一个串行队列
- 自定义并行队列.
*/
同步执行：只要是同步执行的任务，都会在当前线程执行，不会另开线程。 (错)
异步执行：只要是异步执行的任务，都会另开线程，在别的线程执行。(错)
其中,同步（sync） 和 异步（async） 的主要区别在于会不会阻塞当前线程，直到 Block 中的任务执行完毕！ 如果是同步（sync） 操作，它会阻塞当前线程并等待 Block 中的任务执行完毕，然后当前线程才会继续往下运行。 如果是异步（async）操作，当前线程会直接往下执行，它不会阻塞当前线程。
队列：用于存放任务。一共有两种队列， 串行队列 和 并行队列。
串行队列: 放到串行队列的任务，GCD 会 FIFO（先进先出） 地取出来一个，执行一个，然后取下一个，这样一个一个的执行。
并行队列: 放到并行队列的任务，GCD 也会 FIFO的取出来，但不同的是，它取出来一个就会放到别的线程，然后再取出来一个又放到另一个的线程。这样由于取的动作很快，忽略不计，看起来，所有的任务都是一起执行的。不过需要注意，GCD 会根据系统资源控制并行的数量，所以如果任务很多，它并不会让所有任务同时执行。
任何需要刷新 UI 的工作都要在主队列执行，所以一般耗时的任务都要放到别的线程执行。
#pragma mark ** GCD 函数.
void functionOfGCD(void *context){
printf("%s", context);
}
#pragma mark ** GCD实现异步加载图片
- (IBAction)handleImage:(id)sender {
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *data = [session dataTaskWithURL:[NSURL URLWithString:@"http://www.qqpk.cn/Article/UploadFiles/201111/2011112212074796.jpg"] completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
// 回到到主线程中, 添加任务.
dispatch_async(dispatch_get_main_queue(), ^{
self.imageView.image = [UIImage imageWithData:data];
});
}];
[data resume];
}
#pragma mark ** GCD实现单例
+ (instancetype)shareViewController{
static ViewController *vc = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
vc = [[ViewController alloc]init];
});
return vc;
}
它自己可以创建 串行队列, 也可以创建 并行队列.它有两个参数，第一个参数是标识符，用于 DEBUG 的时候标识唯一的队列，可以为空。第二个才是最重要的。第二个参数用来表示创建的队列是串行的还是并行的，传入DISPATCH_QUEUE_SERIAL 或 NULL 表示创建串行队列。传入 DISPATCH_QUEUE_CONCURRENT 表示创建并行队列。
- (IBAction)handleCustomSerial:(id)sender {
//串行队列
dispatch_queue_t queue = dispatch_queue_create("kk", DISPATCH_QUEUE_SERIAL);
// 防止循环引用 使用 __weak 修饰
__weak typeof(self)weakSelf = self;
dispatch_async(queue, ^{
[weakSelf handleFun:nil];
});
//异步任务
dispatch_async(queue, ^{
[weakSelf handleFun:nil];
NSLog(@"不会阻塞当前线程 ");
});
}
注意: 同步任务
dispatch_sync(queue, ^{
NSLog(@"同步任务：会阻塞当前线程 (SYNC)阻塞线程");
});
#pragma mark ** 自定义并行队列
- (IBAction)handleCustomConcurrent:(id)sender {
//并行队列
dispatch_queue_t queue = dispatch_queue_create("concurrent", DISPATCH_QUEUE_CONCURRENT);
//异步
__weak typeof(self)weakSelf = self;
dispatch_async(queue, ^{
[weakSelf handleFun:nil];
});
dispatch_async(queue, ^{
[weakSelf handleFun:nil];
});
}
- (IBAction)handleGCD:(id)sender {
#if 0
// 获取主线程.(获取自带的串行队列)
dispatch_queue_t queue = dispatch_get_main_queue();
// 向队列中异步分发任务.
__weak typeof(self)weakSelf = self;
dispatch_async(queue, ^{
[weakSelf handleFun:nil];
});
#endif
// 获取系统的并行队列(4个).
dispatch_queue_t queque = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
__weak typeof(self)weakSelf = self;
dispatch_async(queque, ^{
[weakSelf handleFun:nil];
});
dispatch_async(queque, ^{
[weakSelf handleFun:nil];
});
// 任务是函数
dispatch_async_f(queque, "dddd", functionOfGCD);
}
从其他线程回到主线程的方法
我们都知道在其他线程操作完成后必须到主线程更新UI。所以，介绍完所有的多线程方案后，我们来看看有哪些方法可以回到主线程。
NSThread
//Objective-C
[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:NO];
GCD
//Objective-C
dispatch_async(dispatch_get_main_queue(), ^{
});
NSOperationQueue
//Objective-C
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
}];
}
线程同步
所谓线程同步就是为了防止多个线程抢夺同一个资源造成的数据安全问题，所采取的一种措施。
互斥锁 ：给需要同步的代码块加一个互斥锁，就可以保证每次只有一个线程访问此代码块。
OBJECTIVE-C
@synchronized(self) {
//需要执行的代码块
}
同步执行 ：我们可以使用多线程的知识，把多个线程都要执行此段代码添加到同一个串行队列，这样就实现了线程同步的概念。
总结:
1.无论使用哪种方法进行多线程开发，每个线程启动后并不一定立即执行相应的操作，具体什么时候由系统调度，CPU空闲时就会执行。
2.更新UI应该在主线程（UI线程）中进行，常用的方法如下：
详见上文
3.NSThread适合轻量级多线程开发，要手动控制线程，线程总数无法控制，无法线程依赖。
4.对于简单的多线程开发建议使用NSObject的扩展方法完成，而不必使用NSThread。
5.可以使用NSThread的currentThread方法取得当前线程，使用 sleepForTimeInterval:方法让当前线程休眠。
6.NSOperation进行多线程开发可以控制线程总数及线程依赖关系。
7.创建一个NSOperation不应该直接调用start方法, 如果直接start则会在主线程中调用, 而是应该放到NSOperationQueue中启动。
8.相比NSInvocationOperation推荐使用NSBlockOperation，代码简单，同时由于闭包性使它没有传参问题。
9.NSOperation是对GCD面向对象的封装，但是GCD基于C语言开发，效率却更高. 建议如果任务之间有依赖关系或者想要监听任务完成状态的情况下优先选择NSOperation否则使用GCD。
10.在GCD中串行队列中的任务被安排到一个单一的子线程中，可以方便地控制执行顺序；并发队列在多个线程中执行（前提是使用异步方法），顺序控制相对复杂，但是更高效。
11.在GDC中一个操作是多线程执行还是单线程执行取决于当前队列类型和执行方法，只有队列类型为并发队列并且使用异步方法执行时才能在多个线程中并发执行。
12.相比使用NSLock，@synchronized更加简单。
感谢:
http://www.jianshu.com/p/0b0d9b1f1f19
http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html
http://guimingsu.com/blog/2015/12/22/thread/
