iOS编程之多线程

1、NSThread ：就是刚刚例子中使用的方式，但是使用上比较繁琐，而且需要控制好数据的同步和异步问题

2、NSOperation 和 NSOperationQueue ： 这种方式代码比较简洁，可读性强，而且使用队列的形式管理多个任务，本人比较喜欢

3、使用GCD( Grand Central Dispatch ) ：相较于NSThread使用简单，使用队列管理任务

一、首先来介绍NSThread

1、创建NSThread的两种方式

-(id) initWithTarget:(id) target selector:(SEL) selector object:(id) arg:

+(void)detachNewThreadSelector:(SEL) selector toTarget:(id) target withObject:(id) arg:

第二种方式，创建NSThread后会自动启动

2、NSThread的常用方法

+currentThread ： 返回当前正在执行的线程对象

3、线程的状态

一开始的例子中提了一下，线程创建后，执行了start方法并不是立即就执行了。可能ui线程执行了几毫秒后，cpu才执行它，执行几毫秒后再执行ui线程，但这个过程是随机发生的。

如果想让线程立即执行，那么可以让ui线程sleep 1毫秒，这样cpu就会执行其他可执行的线程，可以达到立即执行的效果

[NSThread sleepForTimeInterval:0.001];//让当前运行的线程睡眠1毫秒

线程正在执行时，调用isExecuting方法返回 YES ，线程执行完成后调用 isFinished 方法就会返回 YES
4、终止子线程

线程会以一下3种方式之一结束，结束后就处于死亡状态

1）线程执行的方法体执行完成，线程正常结束

2）执行过程中出现了错误

3）调用NSThread 类的 exit 方法来终止当前线程

在UI 线程中 ，NSThread 并没有提供方法来结束其他的子线程。但是我们可以利用 NSThread 的cancel 方法，执行该方法后， 该线程的状态为 isCancelled = YES，但并不会结束线程。

NSThread* thread;
- (void)viewDidLoad
{
    [super viewDidLoad];
    // 创建新线程对象
    thread = [[NSThread alloc] initWithTarget:self selector:@selector(run)
        object:nil];
    // 启动新线程
    [thread start];
}
- (void)run
{
    for(int i = 0 ; i < 100 ; i++)
    {
        if([NSThread currentThread].isCancelled)
        {
            // 终止当前正在执行的线程
            [NSThread exit];
        }
        NSLog(@"-----%@----%d" , [NSThread currentThread].name, i);
        // 每执行一次，线程暂停0.5秒
        [NSThread sleepForTimeInterval:0.5];
    }
}
- (IBAction)cancelThread:(id)sender
{
    // 取消thread线程，调用该方法后，thread的isCancelled方法将会返回NO
    [thread cancel]; 
}

5、线程睡眠

要让线程进入阻塞状态或者睡眠状态，可以执行sleepXXX格式的方法：

+(void) sleepUntilDate:(NSDate *) aDate  : 让线程睡眠，知道aDate那个时间点再醒过来

-(void)sleepForTimeInterval ：让线程睡眠多少秒

6、改变线程优先级

NSThread 提供了如下几个方法来获取和设置线程的优先级

+threadPriority: 获取当前正在执行的线程的优先级

-threadPriority：获取线程实例的优先级

+setThreadPriority :(double) priority ： 设置当前正在执行的线程的优先级

-setThreadPriority :(double) priority ： 设置线程实例的优先级

(double) priority的 取值范围是0.0~1.0；优先级越高的线程获得的执行机会越多

- (void)viewDidLoad
{
    [super viewDidLoad];
    NSLog(@"UI线程的优先级为：%g" , [NSThread threadPriority]);
    // 创建第一个线程对象
    NSThread* thread1 = [[NSThread alloc]
        initWithTarget:self selector:@selector(run) object:nil];
    // 设置第一个线程对象的名字
    thread1.name = @"线程A";
    NSLog(@"线程A的优先级为：%g" , thread1.threadPriority);
    // 设置使用最低优先级
    thread1.threadPriority = 0.0;
    // 创建第二个线程对象
    NSThread* thread2 = [[NSThread alloc]
        initWithTarget:self selector:@selector(run) object:nil];
    // 设置第二个线程对象的名字
    thread2.name = @"线程B";
    NSLog(@"线程B的优先级为：%g" , thread2.threadPriority);
    // 设置使用最高优先级
    thread2.threadPriority = 1.0;
    // 启动2个线程
    [thread1 start];
    [thread2 start];
}
- (void)run
{
    for(int i = 0 ; i < 100 ; i++)
    {
        NSLog(@"-----%@----%d" , [NSThread currentThread].name, i);
    }
}

二、使用GCD实现多线程

GCD简化了多线程的实现，主要有两个核心概念：

1、队列：队列负责管理开发者提交的任务，以先进先出的方式来处理任务。

1）串行队列：每次只执行一个任务，当前一个任务执行完成后才执行下一个任务

2）并行队列：多个任务并发执行，所以先执行的任务可能最后才完成（因为具体的执行过程导致）

2、任务：任务就是开发者提供给队列的工作单元，这些任务将会提交给队列底层维护的线程池，因此这些任务将会以多线程的方式执行。
3、创建队列

1）获取系统默认的全局并发队列：

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
2) 获取系统主线程关联的穿行队列

1 dispatch_queue_t queue = dispatch_get_main_queue();
如果将任务提交给主线程关联的串行队列，那么就相当于在程序主线程中去执行该任务。

3)创建穿行队列

1 dispatch_queue_t queue = dispatch_queue_create("queueName", DISPATCH_QUEUE_SERIAL);
4)创建并发队列

1 dispatch_queue_t queue = dispatch_queue_create("queueName", DISPATCH_QUEUE_CONCURRENT);
5)获取当前执行代码所在队列

dispatch_get_current_queue，返回一个dispatch_queue_t类型的值

4、提交任务

使用下面的方法将任务以同步或者异步的方式提交到队列

//将代码块以异步的方式提交给指定队列
void  dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

//将函数以异步的方式提交给指定队列，一般执行函数的方法与执行代码块的方法比，方法名多了一个_f的后缀
void  dispatch_async_f(dispatch_queue_t queue, void* context, dispatch_function_t work);

//将代码块以同步的方式提交给指定队列
void  dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

//将函数以同步的方式提交给指定队列，一般执行函数的方法与执行代码块的方法比，方法名多了一个_f的后缀
void  dispatch_sync_f(dispatch_queue_t queue, void* context, dispatch_function_t work);

//将代码块以异步的方式提交给指定队列，队列的线程池负责在指定时间点 when 之后执行
void  dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block);

//将函数以异步的方式提交给指定队列，队列的线程池负责在指定时间点 when 之后执行
void  dispatch_after_f(dispatch_time_t when, dispatch_queue_t queue,  void* context, dispatch_function_t work);

//将代码块以异步的方式提交给指定队列，队列的线程池将会重复多次执行该任务
void  dispatch_apply(size_t iterations, dispatch_queue_t queue, void(^block)(size_t));

//将函数以异步的方式提交给指定队列，队列的线程池将会重复多次执行该任务
void  dispatch_apply_f(size_t iterations, dispatch_queue_t queue, void* context, void(*work)(void*, size_t));

//将代码块提交给指定队列，在应用的某个生命周期内金执行一次
void dispatch_once(dispatch_once_t *predicate, dispatch_block_t block);

以异步方式向串行队列、并发队列添加任务的实例

// 定义2个队列
dispatch_queue_t serialQueue;
dispatch_queue_t concurrentQueue;
- (void)viewDidLoad
{
    [super viewDidLoad];
    // 创建串行队列
    serialQueue = dispatch_queue_create("fkjava.queue", DISPATCH_QUEUE_SERIAL);
    // 创建并发队列
    concurrentQueue = dispatch_queue_create("fkjava.queue"
        , DISPATCH_QUEUE_CONCURRENT);
}
- (IBAction)serial:(id)sender
{
    // 依次将2个代码块提交给串行队列
    // 必须等到第1个代码块完成后，才能执行第2个代码块。
    dispatch_async(serialQueue, ^(void)
    {
        for (int i = 0 ; i < 100; i ++)
        {
            NSLog(@"%@=====%d"  , [NSThread currentThread] , i);
        }
    });
    dispatch_async(serialQueue, ^(void)
    {
        for (int i = 0 ; i < 100; i ++)
        {
            NSLog(@"%@------%d" , [NSThread currentThread] , i);
        }
    });
}
- (IBAction)concurrent:(id)sender
{
    // 依次将2个代码块提交给并发队列
    // 两个代码块可以并发执行
    dispatch_async(concurrentQueue, ^(void)
    {
        for (int i = 0 ; i < 100; i ++)
        {
            NSLog(@"%@=====%d"  , [NSThread currentThread] , i);
        }
    });
    dispatch_async(concurrentQueue, ^(void)
    {
        for (int i = 0 ; i < 100; i ++)
        {
            NSLog(@"%@------%d" , [NSThread currentThread] , i);
        }
    });
}

提交同步任务：

- (void)viewDidLoad
{
    [super viewDidLoad];
}
- (IBAction)clicked:(id)sender
{
    // 以同步方式先后提交2个代码块
    dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
        , ^(void){
            for (int i = 0 ; i < 100; i ++)
            {
                NSLog(@"%@=====%d"  , [NSThread currentThread] , i);
                [NSThread sleepForTimeInterval:0.1];
            }
        });
    // 必须等第一次提交的代码块执行完成后，dispatch_sync()函数才会返回，
    // 程序才会执行到这里，才能提交第二个代码块。
    dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
        , ^(void){
            for (int i = 0 ; i < 100; i ++)
            {
                NSLog(@"%@-----%d"  , [NSThread currentThread] , i);
                [NSThread sleepForTimeInterval:0.1];
            }
        });
}

多次执行的任务：

- (void)viewDidLoad
{
    [super viewDidLoad];
}
- (IBAction)clicked:(id)sender
{
    // 控制代码块执行5次
    dispatch_apply(5
        , dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
        // time形参代表当前正在执行第几次
        , ^(size_t time)
        {
            NSLog(@"===执行【%lu】次===%@" , time
                , [NSThread currentThread]);
        });
}

只执行一次的任务

@implementation FKViewController
- (void)viewDidLoad
{
    [super viewDidLoad];
}
- (IBAction)clicked:(id)sender
{    
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"==执行代码块==");
        // 线程暂停3秒
        [NSThread sleepForTimeInterval:3];
    });
}

三、使用NSOperation 和 NSOPerationQueue 实现多线程

和GCD差不多，也是有队列和任务的概念

NSOperationQueue：代表一个先进先出的队列，负责管理系统提交的多个NSOperation。底层维护一个线程池，会按顺序启动线程来执行提交给队列的NSOperation

NSOperation：代表多线程任务。一般不直接使用NSOperation，而是使用NSOperation的子类。或者使用NSInvocationOperation和NSBlockOperation（这两个类继承自NSOperation）；

1、NSOperation的使用

NSOperation 的使用相较于GCD是面向对象的，OC实现的，而GCD应该是C实现的（看函数的定义和使用）。

使用NSOperation 只需两步：

1）创建 NSOperationQueue 队列，并未该队列设置相关属性

2）创建 NSOperation 子类对象，并将该对象提交给 NSOperationQueue 队列，该队列将会按顺序依次启动每个 NSOperation。
2、NSOperationQueue的常用方法：

+currentQueue //类方法，返回执行当前NSOperation的NSOperationQueue队列

+mainQueue //返回系统主线程的NSOperationQueue队列

-(void) addOperation:(NSOperation *) operation //将operation添加到NSOperationQueue队列中

-(void) addOperations:(NSArray *) ops waitUnitlFinished:(BOLL) wait //将NSArray中包含的所有NSOperation添加到NSOperationQueue。如果第二个参数指定为YES，将会阻塞当前线程，直到提交的所有NSOperation执行完成。如果第二个参数为NO，该方法立即返回，NSArray包含的NSOperation将以异步方式执行，不会阻塞当前线程。

- operations //只读属性，返回该NSOperationQueue管理的所有NSOperation
-operationCount //只读属性，返回该NSOperationQueue管理的所有NSOperation数量

-cancelAllOperations: //取消NSOperationQueue队列中所有正在排队和执行的NSOperation

-waitUntilAllOperationsAreFinished://阻塞当前线程，直到该NSOperationQueue中所有排队和执行的NSOperation执行完成再接触阻塞

-(NSInteger) maxConcurrentOperationCount://返回该队列最大支持多少个并发线程

-setMaxConcurrentOperationCount:(NSInteger) count //设置该队列最大支持多少个并发线程

-setSuspended:(BOOL) suspend: //设置NSOperationQueue是否已经暂停调度正在排队的NSOperation

-(BOLL) isSuspended: //返回NSOperationQueue是否已经暂停调度正在排队的NSOperation

3、使用NSInvocationOperation 和 NSBlockOperation

NSInvocationOperation 和 NSBlockOperation 继承自 NSOperation，所以可以直接使用，用于封装需要异步执行的任务。

NSOperationQueue* queue;
- (void)viewDidLoad
{
    [super viewDidLoad];
    queue = [[NSOperationQueue alloc]init];
    // 设置该队列最多支持10条并发线程
    queue.maxConcurrentOperationCount = 10;
}
- (IBAction)clicked:(id)sender
{
    NSString* url = @"http://www.......jpg";
    // 以传入的代码块作为执行体，创建NSOperation
    NSBlockOperation* operation = [NSBlockOperation
        blockOperationWithBlock:^{
            // 从网络获取数据
            NSData *data = [[NSData alloc]
                initWithContentsOfURL:[NSURL URLWithString:url]];
            // 将网络数据初始化为UIImage对象
            UIImage *image = [[UIImage alloc]initWithData:data];
            if(image != nil)
            {
                // 在主线程中执行updateUI:方法
                [self performSelectorOnMainThread:@selector(updateUI:)
                    withObject:image waitUntilDone:YES];
            }
            else
            {
                NSLog(@"---下载图片出现错误---");
            }
        }];
    // 将NSOperation添加给NSOperationQueue
    [queue addOperation:operation];
}
-(void)updateUI:(UIImage*) image
{
    self.iv.image = image;
}

NSOperationQueue* queue;
- (void)viewDidLoad
{
    [super viewDidLoad];
    queue = [[NSOperationQueue alloc]init];
    // 设置该队列最多支持10条并发线程
    queue.maxConcurrentOperationCount = 10;
}
- (IBAction)clicked:(id)sender
{
    NSString* url = @"http://www.......jpg";
    // 以self的downloadImageFromURL:方法作为执行体，创建NSOperation
    NSInvocationOperation* operation = [[NSInvocationOperation alloc]
        initWithTarget:self selector:@selector(downloadImageFromURL:)
        object:url];
    // 将NSOperation添加给NSOperationQueue
    [queue addOperation:operation];
}

// 定义一个方法作为线程执行体。
-(void)downloadImageFromURL:(NSString *) url
{
    // 从网络获取数据
    NSData *data = [[NSData alloc]
        initWithContentsOfURL:[NSURL URLWithString:url]];
    // 将网络数据初始化为UIImage对象
    UIImage *image = [[UIImage alloc]initWithData:data];
    if(image != nil)
    {
        // 在主线程中执行updateUI:方法
        [self performSelectorOnMainThread:@selector(updateUI:)
            withObject:image waitUntilDone:YES];
    }
    else
    {
        NSLog(@"---下载图片出现错误---");
    }
}
-(void)updateUI:(UIImage*) image
{
    self.iv.image = image;
}

4、自定义NSOperation 的子类

创建 NSOperation 的子类，需要重写一个方法：-(void) main，该方法的方法体将作为 NSOperationQueue 完成的任务

下面自定义一个NSOperation 子类来实现下载图片的功能

 @interface MyDownImageOperation : NSOperation
 @property (nonatomic , strong) NSURL* url;
 @property (nonatomic , weak) UIImageView* imageView;
 - (id)initWithURL:(NSURL*)url imageView:(UIImageView*)iv;
 @end

@implementation MyDownImageOperation
- (id)initWithURL:(NSURL*)url imageView:(UIImageView*)iv
{
    self = [super init];
    if (self) {
        _imageView = iv;
        _url = url;
    }
    return self;
}
// 重写main方法，该方法将作为线程执行体
- (void)main
{    
    // 从网络获取数据
    NSData *data = [[NSData alloc]
        initWithContentsOfURL:self.url];
    // 将网络数据初始化为UIImage对象
    UIImage *image = [[UIImage alloc]initWithData:data];
    if(image != nil)
    {
        // 在主线程中执行updateUI:方法
        [self performSelectorOnMainThread:@selector(updateUI:)
            withObject:image waitUntilDone:YES]; // ①
    }
    else
    {
        NSLog(@"---下载图片出现错误---");
    }
}
-(void)updateUI:(UIImage*) image
{
    self.imageView.image = image;
}

NSOperationQueue* queue;
- (void)viewDidLoad
{
    [super viewDidLoad];
    queue = [[NSOperationQueue alloc]init];
    // 设置该队列最多支持10条并发线程
    queue.maxConcurrentOperationCount = 10;
}
- (IBAction)clicked:(id)sender
{
    // 定义要加载的图片的URL
    NSURL* url = [NSURL URLWithString:@"http://www.crazyit.org/logo.jpg"];
    // 创建FKDownImageOperation对象
    MyDownImageOperation* operation = [[MyDownImageOperation alloc]
        initWithURL:url imageView:self.iv];
    // 将NSOperation的子类的实例提交给NSOperationQueue
    [queue addOperation:operation];
}