多线程

作者: DDY | 来源:发表于2016-11-10 10:54 被阅读26次

MultiThread.png

https://github.com/starainDou 欢迎点星

概念

进程

指在系统中正在运行的一个应用程序，进程拥有独立运行所需的全部资源（例如：正在运行的QQ就是一个进程）。

线程

指程序中独立运行的代码段（例如：接收QQ消息的代码），一个进程是由一或多个线程组成。

多线程

1个进程中可以开启多条线程，每条线程可以并行（同时）执行不同的任务，进程只负责资源的调度和分配，线程才是程序真正的执行单元，负责代码的执行。

单线程与多线程对比

单线程程序：只有一个线程，代码顺序执行，容易出现代码阻塞（页面假死）。
多线程程序：有多个线程，线程间独立运行，能有效的避免代码阻塞，并且提高程序的运行性能。

线程相关

同步线程：同步线程会阻塞当前线程去执行线程内的任务，执行完之后才会反回当前线程。
异步线程：异步线程不会阻塞当前线程，会开启其他线程去执行线程内的任务。
串行队列：线程任务按先后顺序逐个执行（需要等待队列里面前面的任务执行完之后再执行新的任务）。
并发队列：多个任务按添加顺序一起开始执行（不用等待前面的任务执行完再执行新的任务），但是添加间隔往往忽略不计，所以看着像是一起执行的。
并发VS并行：并行是基于多核设备的，并行一定是并发，并发不一定是并行。

死锁

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去
例如主线程串行队列同步执行任务：
dispatch_sync(dispatch_get_main_queue(),^{
NSLog("MainQueue");
});

自定义串行队列嵌套执行同步任务，产生死锁
dispatch_queue_t serialQueue = dispatch_queue_create("com.baidu.serialQueue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(serialQueue, ^{ //该代码段后面的代码都不会执行，程序被锁定在这里
NSLog(@"会执行的代码");
dispatch_sync(serialQueue, ^{
NSLog(@"代码不执行");
});
});

嵌套使用dispatch_apply会导致死锁

死锁的四个必要条件：

（1）互斥条件：一个资源每次只能被一个进程使用。
（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3）不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4）循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

避免死锁的方法：

（1）破坏“互斥”条件:就是在系统里取消互斥。若资源不被一个进程独占使用，那么死锁是肯定不会发生的。但一般“互斥”条件是无法破坏的。因此，在死锁预防里主要是破坏其他三个必要条件，而不去涉及破坏“互斥”条件。

（2）破坏“请求和保持”条件:在系统中不允许进程在已获得某种资源的情况下，申请其他资源。即要想出一个办法，阻止进程在持有资源的同时申请其他资源。
方法：要求每个进程提出新的资源申请前，释放它所占有的资源。这样，一个进程在需要资源S时，须先把它先前占有的资源R释放掉，然后才能提出对S的申请，即使它可能很快又要用到资源R。

（3）破坏“不可抢占”条件：允许对资源实行抢夺。
方法一：如果占有某些资源的一个进程进行进一步资源请求被拒绝，则该进程必须释放它最初占有的资源，如果有必要，可再次请求这些资源和另外的资源。
方法二：如果一个进程请求当前被另一个进程占有的一个资源，则操作系统可以抢占另一个进程，要求它释放资源。只有在任意两个进程的优先级都不相同的条件下，该方法才能预防死锁。

（4）破坏“循环等待”条件：将系统中的所有资源统一编号，进程可在任何时刻提出资源申请，但所有申请必须按照资源的编号顺序（升序）提出。这样做就能保证系统不出现死锁。
方法：利用银行家算法避免死锁。

死锁

线程安全

一段线程安全的代码（对象），可以同时被多个线程或并发的任务调度，不会产生问题，非线程安全的只能按次序被访问。所有Mutable对象都是非线程安全的，所有Immutable对象都是线程安全的，使用Mutable对象，一定要用同步锁来同步访问（@synchronized）。
互斥锁：能够防止多线程抢夺造成的数据安全问题，但是需要消耗大量的资源
原子属性（atomic）加锁
atomic: 原子属性，为setter方法加锁，将属性以atomic的形式来声明，该属性变量就能支持互斥锁了。
nonatomic: 非原子属性，不会为setter方法加锁，声明为该属性的变量，客户端应尽量避免多线程争夺同一资源。

几种多线程技术比较

NSThread (抽象层次：低)

优点：轻量级，简单易用，可以直接操作线程对象
缺点: 需要自己管理线程的生命周期，线程同步。线程同步对数据的加锁会有一定的系统开销。

Cocoa NSOperation (抽象层次：中)

优点：不需要关心线程管理，数据同步的事情，可以把精力放在学要执行的操作上。基于GCD，是对GCD 的封装，比GCD更加面向对象
缺点: NSOperation是个抽象类，使用它必须使用它的子类，可以实现它或者使用它定义好的两个子类NSInvocationOperation、NSBlockOperation.

GCD 全称Grand Center Dispatch (抽象层次：高)

优点：是 Apple 开发的一个多核编程的解决方法，简单易用，效率高，速度快，基于C语言，更底层更高效，并且不是Cocoa框架的一部分，自动管理线程生命周期（创建线程、调度任务、销毁线程）。
缺点: 使用GCD的场景如果很复杂，就有非常大的可能遇到死锁问题。

GCD抽象层次最高，使用也简单，因此，苹果也推荐使用GCD

为什么要用 GCD 呢？

GCD 可用于多核的并行运算
GCD 会自动利用更多的 CPU 内核（比如双核、四核）
GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码

GCD

GCD中的三种队列类型

1.主线程串行队列（main queue）：与主线程功能相同，提交至Main queue的任务会在主线程中执行，Main queue 可以通过dispatch_get_main_queue()来获取。
2.全局并发队列（Global queue）：全局并发队列由整个进程共享，有高、中（默认）、低、后台四个优先级别。Global queue 可以通过调用dispatch_get_global_queue函数来获取（可以设置优先级）

自定义队列(Custom queue): 可以为串行，也可以为并发。Custom queue 可以通过dispatch_queue_create()来获取；

队列组 (Group queue)：将多线程进行分组，最大的好处是可获知所有线程的完成情况。
Group queue 可以通过调用dispatch_group_create()来创建，通过dispatch_group_notify 可以直接监听组里所有线程完成情况。

主线程串行队列(The main queue)

1.主线程串行队列同步执行任务，在主线程运行时，会产生死锁

dispatch_queue_t mainQueue = dispatch_get_main_queue();
dispatch_sync(mainQueue,^{
  NSLog("MainQueue");            
});

2.主线程串行队列异步执行任务，在主线程运行，不会产生死锁。

dispatch_queue_t mainQueue = dispatch_get_main_queue();
dispatch_async(mainQueue,^{
  NSLog("MainQueue");            
});

3.从子线程异步执行的任务返回主线程串行队列同步执行任务（例如更新UI）

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
   dispatch_async(globalQueue, ^{
       //子线程异步执行下载任务，防止主线程卡顿
       NSURL *url = [NSURL URLWithString:@"http://www.baidu.com"];
       NSError *error;
       NSString *htmlData = [NSString stringWithContentsOfURL:url encoding:NSUTF8StringEncoding error:&error];
       if (htmlData != nil) {
           dispatch_queue_t mainQueue = dispatch_get_main_queue();
            //异步返回主线程，根据获取的数据，更新UI
           dispatch_async(mainQueue, ^{
               NSLog(@"更新UI界面");
           });
       } else {
           NSLog(@"error when download:%@",error);
       }
  });

注意：主线程串行队列由系统默认生成，无法调用dispatch_resume()和dispatch_suspend()来控制执行继续或中断。

全局并发队列(Global queue)

耗时操作(如网络请求，IO，数据库读写等，在子线程中处理，然后通知主线程更新界面。

1 全局并发队列同步执行任务，在主线程执行会导致页面卡顿。

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
NSLog(@"current task");
dispatch_sync(globalQueue, ^{
       sleep(10.0);
       NSLog(@"sleep 10s");
});
NSLog(@"next task");

2 全局并发队列异步执行任务，会开启新的子线程去执行任务，页面不会卡顿。

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
NSLog(@"current task");
dispatch_async(globalQueue, ^{
      sleep(2.0);
      NSLog(@"sleep 2.0s");
});
NSLog(@"next task");

3 多个全局并发队列，异步执行任务。

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
NSLog(@"0");
dispatch_async(globalQueue, ^{
       NSLog(@"1");
});
dispatch_async(globalQueue, ^{
       NSLog(@"2");
});
NSLog(@"3");

异步线程的执行顺序是不确定的，几乎同步开始执行，1和2 顺序不确定
全局并发队列由系统默认生成，无法调用dispatch_resume()和dispatch_suspend()来控制执行继续或中断。

*自定义队列 (Custom queue)

1 自定义串行队列同步执行任务(依次执行)

dispatch_queue_t serialQueue = dispatch_queue_create("com.baidu.serialQueue", DISPATCH_QUEUE_SERIAL);
NSLog(@"0");
dispatch_sync(serialQueue, ^{
   NSLog(@"1");
   sleep(2);
});
dispatch_sync(serialQueue, ^{
   NSLog(@"2");
});
NSLog(@"3");

2 自定义串行队列嵌套执行同步任务，产生死锁

dispatch_queue_t serialQueue = dispatch_queue_create("com.dullgrass.serialQueue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(serialQueue, ^{   //该代码段后面的代码都不会执行，程序被锁定在这里
  NSLog(@"会执行的代码");
  dispatch_sync(serialQueue, ^{
      NSLog(@"代码不执行");
  });
});

3 异步执行串行队列，嵌套同步执行串行队列，同步执行的串行队列中的任务将不会被执行，其他程序正常执行

dispatch_queue_t serialQueue = dispatch_queue_create("com.dullgrass.serialQueue", DISPATCH_QUEUE_SERIAL);
dispatch_async(serialQueue, ^{
  NSLog(@"会执行的代码");
  dispatch_sync(serialQueue, ^{
      NSLog(@"代码不执行");
  });
});

注意:不要嵌套使用同步执行的串行队列任务

4 自定义并发队列执行同步任务(顺序执行)

dispatch_queue_t conCurrentQueue = dispatch_queue_create("com.baidu.conCurrentQueue", DISPATCH_QUEUE_CONCURRENT);
NSLog(@"0");
dispatch_sync(conCurrentQueue, ^{
     NSLog(@"1");
});
dispatch_sync(conCurrentQueue, ^{
     NSLog(@"2");
});
NSLog(@"3");

5 自定义并发队列嵌套执行同步任务（不会产生死锁，程序正常顺序运行）

dispatch_queue_t conCurrentQueue = dispatch_queue_create("com.dullgrass.conCurrentQueue", DISPATCH_QUEUE_CONCURRENT);
NSLog(@"current task");
dispatch_sync(conCurrentQueue, ^{
     NSLog(@"先加入队列");
     dispatch_sync(conCurrentQueue, ^{
         NSLog(@"次加入队列");
     });
});
NSLog(@"next task");

6 自定义并发队列执行异步任务（1，2不确定顺序）

dispatch_queue_t conCurrentQueue = dispatch_queue_create("com.dullgrass.conCurrentQueue", DISPATCH_QUEUE_CONCURRENT);
NSLog(@"0");
dispatch_async(conCurrentQueue, ^{
     NSLog(@"1");
});
dispatch_async(conCurrentQueue, ^{
     NSLog(@"2");
});
NSLog(@"3");

队列组(Group queue)

使用场景：同时下载多个图片，所有图片下载完成之后去更新UI（需要回到主线程）或者去处理其他任务（可以是其他线程队列）。
原理：使用函数dispatch_group_create创建dispatch group,然后使用函数dispatch_group_async来将要执行的block任务提交到一个dispatch queue。同时将他们添加到一个组，等要执行的block任务全部执行完成之后，使用dispatch_group_notify函数接收完成时的消息。
使用示例:

dispatch_group_t group = dispatch_group_create();
 dispatch_queue_t serialQueue = dispatch_queue_create("com.634778311.www", DISPATCH_QUEUE_SERIAL);
 dispatch_group_enter(group);
 dispatch_group_async(group, serialQueue, ^{
     // 网络请求一
     [DDYRequest getDataSuccess:^(ResponseModel *model) {
         dispatch_group_leave(group);
     } failure:^(NSString *err) {
         dispatch_group_leave(group);
     }];
 });
 dispatch_group_enter(group);
 dispatch_group_async(group, serialQueue, ^{
     // 网络请求二
     [DDYRequest getDataSuccess:^(ResponseModel *model) {
         dispatch_group_leave(group);
     } failure:^(NSString *err) {
         dispatch_group_leave(group);
     }];
 }); 
 // 所有网络请求结束后会来到这个方法
 dispatch_group_notify(group, serialQueue, ^{
     dispatch_async(dispatch_get_global_queue(0, 0), ^{
         dispatch_async(dispatch_get_main_queue(), ^{
             // 刷新UI
         });
     });
 });

在当前线程阻塞的同步等待dispatch_group_wait

dispatch_group_t groupQueue = dispatch_group_create();
dispatch_time_t delayTime = dispatch_time(DISPATCH_TIME_NOW, 10 * NSEC_PER_SEC);
dispatch_queue_t conCurrentGlobalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
NSLog(@"current task");
dispatch_group_async(groupQueue, conCurrentGlobalQueue, ^{

      long isExecuteOver = dispatch_group_wait(groupQueue, delayTime);
      if (isExecuteOver) {
          NSLog(@"wait over");
      } else {
          NSLog(@"not over");
      }
      NSLog(@"并行任务1");
});
dispatch_group_async(groupQueue, conCurrentGlobalQueue, ^{
      NSLog(@"并行任务2");
});

dispatch_time(dispatch_time_t when, int64_t delta);
参数注释：
第一个参数一般是DISPATCH_TIME_NOW，表示从现在开始
第二个参数是延时的具体时间
延时1秒可以写成如下几种：
NSEC_PER_SEC----每秒有多少纳秒
dispatch_time(DISPATCH_TIME_NOW, 1NSEC_PER_SEC);
USEC_PER_SEC----每秒有多少毫秒（注意是指在纳秒的基础上）
dispatch_time(DISPATCH_TIME_NOW, 1000USEC_PER_SEC); //SEC---毫秒
NSEC_PER_USEC----每毫秒有多少纳秒。
dispatch_time(DISPATCH_TIME_NOW, USEC_PER_SEC*NSEC_PER_USEC);SEC---纳秒

GCD中一些系统提供的常用dispatch方法

1.dispatch_after延时添加到队列

只是延时提交block，并不是延时后立即执行，并不能做到精确控制，需要精确控制时慎用
三个参数：param1延迟时间，param2队列，param3block块

dispatch_time_t delayTime3 = dispatch_time(DISPATCH_TIME_NOW, 3*NSEC_PER_SEC);
dispatch_time_t delayTime2 = dispatch_time(DISPATCH_TIME_NOW, 2*NSEC_PER_SEC);
dispatch_queue_t mainQueue = dispatch_get_main_queue();
NSLog(@"current task");
dispatch_after(delayTime3, mainQueue, ^{
      NSLog(@"3秒之后添加到队列");
});
dispatch_after(delayTime2, mainQueue, ^{
       NSLog(@"2秒之后添加到队列");
});
NSLog(@"next task");

2 dispatch_apply 快速迭代方法,
作用是把指定次数指定的block添加到queue中, 第一个参数是迭代次数，第二个是所在的队列，第三个是当前索引，dispatch_apply可以利用多核的优势，所以输出的index顺序不是一定的。
/dispatch_apply 和 dispatch_apply_f 是同步函数,会阻塞当前线程直到所有循环迭代执行完成。当提交到并发queue时,循环迭代的执行顺序是不确定的。
应用场景：
如果我们从服务器获取一个数组的数据，那么我们可以使用该方法从而快速的批量字典转模型。

    NSArray *dictArray = nil;//存放从服务器返回的字典数组
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        dispatch_apply(dictArray.count, queue,  ^(size_t index){
            //字典转模型
        });
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"主线程更新");
        });
    });

注意：嵌套使用dispatch_apply会导致死锁

3 dispatch_semaphore(信号量)

// 创建信号量，参数：信号量的初值，表示允许几个线程访问，如果小于0则会返回NULL
dispatch_semaphore_create（信号量值）

// 等待降低信号量，等待时间枚举（DISPATCH_TIME_NOW，DISPATCH_TIME_FOREVER）
dispatch_semaphore_wait（信号量，等待时间枚举值）

// 提高(发送)信号量
dispatch_semaphore_signal(信号量)

dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);   
dispatch_queue_t quene = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//任务1
dispatch_async(quene, ^{
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"run task 1");
    sleep(1);
    NSLog(@"complete task 1");
    dispatch_semaphore_signal(semaphore);       
});
//任务2
dispatch_async(quene, ^{
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"run task 2");
    sleep(1);
    NSLog(@"complete task 2");
    dispatch_semaphore_signal(semaphore);       
});

信号量的理解及使用
 信号量-线程加锁

4 dispatch_once 保证在app运行期间，block中的代码只执行一次

经典使用场景－－－单例
单例对象ShareManager的定义

ShareManager的.h文件
 #import <Foundation/Foundation.h>
 @interface ShareManager : NSObject
 @property (nonatomic, copy) NSString *someProperty;
+ (ShareManager *)shareManager;
+ (ShareManager *)sharedManager;
@end

ShareManager的.m文件
#import "ShareManager.h"
@implementation ShareManager
static ShareManager *sharedManager = nil;
//GCD实现单例功能
+ (ShareManager *)shareManager
{
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
      sharedManager = [[self alloc] init];
  });
  return sharedManager;
 }
//在ARC下，非GCD，实现单例功能
+ (ShareManager *)sharedManager
{
  @synchronized(self) {
      if (!sharedManager) {
          sharedManager = [[self alloc] init];
      }
  }
  return sharedManager;
 }
- (instancetype)init{
  self = [super init];
  if (self) {
       _someProperty =@"Default Property Value";
  }
  return self;
}
@end

ShareManager的使用
#import "ShareManager.h"
在需要使用的函数中，直接调用下面的方法
ShareManager *share = [ShareManager sharedManager];
NSLog(@"share is %@",share.someProperty);

// 还有一种直接使用懒加载方式创建单例，线程不安全，不建议采用

5 dispatch_barrier_async 栅栏操作

功能：是在并行队列中，等待在dispatch_barrier_async之前加入的队列全部执行完成之后（这些任务是并发执行的）再执行dispatch_barrier_async中的任务，dispatch_barrier_async中的任务执行完成之后，再去执行在dispatch_barrier_async之后加入到队列中的任务（这些任务是并发执行的）。
使用示例:

dispatch_queue_t conCurrentQueue = dispatch_queue_create("com.baidu.conCurrentQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(conCurrentQueue, ^{
    NSLog(@"dispatch 1-1");
});
dispatch_async(conCurrentQueue, ^{
    NSLog(@"dispatch 1-2");
});
dispatch_async(conCurrentQueue, ^{
    NSLog(@"dispatch 1-3");
});
dispatch_barrier_async(conCurrentQueue, ^{
    NSLog(@"dispatch barrier");
    dispatch_async(conCurrentQueue, ^{
        NSLog(@"dispatch 2-1");
    });
    dispatch_async(conCurrentQueue, ^{
        NSLog(@"dispatch 2-2");
    });
    dispatch_async(conCurrentQueue, ^{
        NSLog(@"dispatch 2-3");
    });
});
dispatch_async(conCurrentQueue, ^{
    NSLog(@"dispatch 3-1");
});
dispatch_async(conCurrentQueue, ^{
    NSLog(@"dispatch 3-2");
});
dispatch_async(conCurrentQueue, ^{
  NSLog(@"dispatch 3-3");
});

打印结果：

2018-04-17 10:20:43.598 FireFlyChat[7044:920515] dispatch 1-1
2018-04-17 10:20:43.598 FireFlyChat[7044:920515] dispatch 1-2
2018-04-17 10:20:43.599 FireFlyChat[7044:920515] dispatch 1-3
2018-04-17 10:20:43.599 FireFlyChat[7044:920501] dispatch barrier
2018-04-17 10:20:43.600 FireFlyChat[7044:920524] dispatch 3-1
2018-04-17 10:20:43.600 FireFlyChat[7044:920524] dispatch 3-3
2018-04-17 10:20:43.600 FireFlyChat[7044:920524] dispatch 2-1
2018-04-17 10:20:43.600 FireFlyChat[7044:920522] dispatch 3-2
2018-04-17 10:20:43.600 FireFlyChat[7044:920516] dispatch 2-2
2018-04-17 10:20:43.600 FireFlyChat[7044:920524] dispatch 2-3

2-n 和 3-n 顺序不确定，但是都是在所有1-n执行结束后执行

http://www.jianshu.com/p/ae786a4cf3b1
http://cbsfly.github.io/ios/rac1
iOS多线程全套：生命周期，线程安全，GCD、NSOperation的使用
 NSOperation&NSOperationQueue详细总结
 GCD详尽总结
 pThread & NSThread详尽总结
 GCD学习之GCD（Grand Central Dispatch）

多线程

概念

几种多线程技术比较

GCD

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读