线程基础及NSThread,GCD,NSOperation简单使用

一.多线程

• 进程是指在系统中正在运行的一个应用程序。每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内。（比如同时打开迅雷、Xcode，系统就会分别启动2个进程。）

• 线程是进程的基本执行单元，1个进程要想执行任务，必须得有线程（每1个进程至少要有1条线程,并且1个线程中任务的执行是串行的）。

• 多线程是指1个进程中可以开启多条线程，多条线程可以并行（同时）执行不同的任务。

1.线程的并行：

 并行即同时执行。比如同时开启3条线程分别下载3个文件（分别是文件A、文件B、文件C）

2.多线程并发执行的原理：

 a. 在同一时间里，CPU只能处理 1 条线程，只有 1 条线程在工作（执行）
 b. 多线程并发（同时）执行，其实是CPU快速地在多条线程之间调度（切换），如果CPU调度线程的时间足够快，就造成了多线程并发执行的假象

3.优缺点

3.1优点

 a. 能适当提高程序的执行效率
 b. 能适当提高资源利用率（CPU、内存利用率）

3.2缺点

 a. 开启线程需要占用一定的内存空间（默认情况下，主线程占用1M，子线程占用512KB），如果开启大量的线程，会占用大量的内存空间，降低程序的性能
 b. 线程越多，CPU在调度线程上的开销就越大
 c. 程序设计更加复杂：比如线程之间的通信、多线程的数据共享

4.多线程在ios中的应用

4.1主线程

 a. 一个iOS程序运行后，默认会开启 1 条线程，称为“主线程”或“UI 线程”
 b. 作用：刷新显示 UI，处理 UI 事件

4.2子线程

 a. 除了主线程之外的所有线程，也叫做后台线程
 b. 子线程不能用来刷新 UI

注意：

 a. 不要将耗时操作放到主线程中去处理，因为会卡住线程,造成画面卡顿的现象
 b. 和UI相关的刷新操作必须放到主线程中进行处理

5.多线程安全隐患

• 资源共享

1块资源可能会被多个线程共享，也就是多个线程可能会访问同一块资源
比如多个线程访问同一个对象、同一个变量、同一个文件

• 当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题

安全隐患解决– 互斥锁

• 互斥锁使用格式

// 注意：锁定1份代码只用1把锁，用多把锁是无效的
@synchronized(锁对象){ //需要锁定的代码  }

• 互斥锁的优缺点

优点：能有效防止因多线程抢夺资源造成的数据安全问题
缺点：需要消耗大量的CPU资源

• 互斥锁的使用前提：

多条线程抢夺同一块资源

• 线程同步: 多条线程在同一条线上执行（按顺序地执行任务）

互斥锁，就是使用了线程同步技术

6.线程间通信

1个线程传递数据给另1个线程
在1个线程中执行完特定任务后，转到另1个线程继续执行任务

二.ios中常用多线程方案

• NSThread

1.创建方式

//1.实例方法
 NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector(loadImage) object:nil];
[thread start];
//2.类方法
 [NSThread detachNewThreadSelector:@selector(loadImage) toTarget:self withObject:nil];
//3.//隐式创建线程
 [self performSelectorInBackground:@selector(loadImage) withObject:self];

2.当前线程获取

NSThread *current = [NSThread currentThread];

3.获取主线程

NSThread *main = [NSThread mainThread];
//判断是否为主线程
-(BOOL)isMainThread;
+(BOOL)isMainThread;

4.暂停当前线程

[NSThread sleepForTimeInterval:2];

5.强制停止

+(void)exit;

6.线程之间通信

//在指定线程上执行操作
[self performSelector:@selector(run) onThread:thread withObject:nil waitUntilDone:YES]; 
//在主线程上执行操作
[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:YES]; 
//在当前线程执行操作
[self performSelector:@selector(run) withObject:nil];

7.简单使用

//创建线程
-(void)implicitCreateThread{

[self performSelectorInBackground:@selector(loadImageSource:) withObject:imgUrl];

}
//下载图片数据

-(void)loadImageSource:(NSString *)url{

    NSData *imgData = [NSData dataWithContentsOfURL:[NSURL URLWithString:url]];
    UIImage *image = [UIImage imageWithData:imgData];
    
    if (imgData!= nil) {
        //主线程中跟新界面
        [self performSelectorOnMainThread:@selector(refreshImageView:) withObject:image waitUntilDone:YES];
    }else{
        NSLog(@"NoData");
    }
}
//跟新界面
-(void)refreshImageView:(UIImage *)image{

[self.imageView setImage:image];

}

• GCD

一.GCD中主要核心概念为任务和队列

• 任务：你在线程中执行的那段代码。分为以下两种.

同步执行（sync）：只能在当前线程中执行任务，不具备开启新线程的能力
异步执行（async）：可以在新的线程中执行任务，具备开启新线程的能力

• 队列:用来存放任务的队。采用FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。分为以下两种.

并发队列（Concurrent Dispatch Queue）：可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
并发功能只有在异步（dispatch_async）函数下才有效
串行队列（Serial Dispatch Queue）：让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）

二.GCD创建

GCD创建分为两步

1.创建一个队列（串行队列或并发队列）
2.将任务添加到队列中，然后系统就会根据任务类型执行任务（同步执行或异步执行）
下边来看看队列的创建方法和任务的创建方法。

1.队列的创建方法

// 串行队列的创建方法
dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
// 并发队列的创建方法
dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
//主队列,GCD自带的一种特殊的串行队列
dispatch_queue_t queue = dispatch_get_main_queue();

对于并发队列，还可以使用dispatch_get_global_queue来创建全局并发队列。GCD默认提供了全局的并发队列，需要传入两个参数。第一个参数表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用，用0即可。

2.任务的创建方法

// 同步执行任务创建方法
dispatch_sync(queue, ^{
    NSLog(@"%@",[NSThread currentThread]);    // 这里放任务代码
});
// 异步执行任务创建方法
dispatch_async(queue, ^{
    NSLog(@"%@",[NSThread currentThread]);    // 这里放任务代码
});

这里根据队列和任务的不同共有6种组合方式。

	并发队列	串行队列	主队列
同步(sync)	没有开启新线程，串行执行任务	没有开启新线程，串行执行任务	没有开启新线程，串行执行任务
异步(async)	有开启新线程，并发执行任务	有开启新线程(1条)，串行执行任务	没有开启新线程，串行执行任务

• 并发队列 + 同步执行

不会开启新线程，执行完一个任务，再执行下一个任务

- (void) syncConcurrent
{
    NSLog(@"syncConcurrent---begin");

    dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);

    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1------%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2------%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"3------%@",[NSThread currentThread]);
        }
    });

    NSLog(@"syncConcurrent---end");
}

输出结果：
2016-09-03 19:22:27.577 GCD[11557:1897538] syncConcurrent---begin
2016-09-03 19:22:27.578 GCD[11557:1897538] 1------{number = 1, name = main}
2016-09-03 19:22:27.578 GCD[11557:1897538] 1------{number = 1, name = main}
2016-09-03 19:22:27.578 GCD[11557:1897538] 2------{number = 1, name = main}
2016-09-03 19:22:27.579 GCD[11557:1897538] 2------{number = 1, name = main}
2016-09-03 19:22:27.579 GCD[11557:1897538] 3------{number = 1, name = main}
2016-09-03 19:22:27.579 GCD[11557:1897538] 3------{number = 1, name = main}
2016-09-03 19:22:27.579 GCD[11557:1897538] syncConcurrent---end

1.从并发队列 + 同步执行中可以看到，所有任务都是在主线程中执行的。由于只有一个线程，所以任务只能一个一个执行。
2.同时我们还可以看到，所有任务都在打印的syncConcurrent-begin和syncConcurrent---end之间，这说明任务是添加到队列中马上执行的。

• 并发队列 + 异步执行

可同时开启多线程，任务交替执行

- (void) asyncConcurrent
{
    NSLog(@"asyncConcurrent---begin");

    dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);

    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1------%@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2------%@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"3------%@",[NSThread currentThread]);
        }
    });

    NSLog(@"asyncConcurrent---end");
}

输出结果：
2016-09-03 19:27:31.503 GCD[11595:1901548] asyncConcurrent---begin
2016-09-03 19:27:31.504 GCD[11595:1901548] asyncConcurrent---end
2016-09-03 19:27:31.504 GCD[11595:1901626] 1------{number = 2, name = (null)}
2016-09-03 19:27:31.504 GCD[11595:1901625] 2------{number = 4, name = (null)}
2016-09-03 19:27:31.504 GCD[11595:1901855] 3------{number = 3, name = (null)}
2016-09-03 19:27:31.504 GCD[11595:1901626] 1------{number = 2, name = (null)}
2016-09-03 19:27:31.504 GCD[11595:1901625] 2------{number = 4, name = (null)}
2016-09-03 19:27:31.505 GCD[11595:1901855] 3------{number = 3, name = (null)}

1.在并发队列 + 异步执行中可以看出，除了主线程，又开启了3个线程，并且任务是交替着同时执行的。
2.另一方面可以看出，所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始异步执行。

• 串行队列 + 同步执行

不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务

- (void) syncSerial
{
    NSLog(@"syncSerial---begin");

    dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);

    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1------%@",[NSThread currentThread]);
        }
    });    
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2------%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"3------%@",[NSThread currentThread]);
        }
    });

    NSLog(@"syncSerial---end");
}

输出结果为：
2016-09-03 19:29:00.066 GCD[11622:1903904] syncSerial---begin
2016-09-03 19:29:00.067 GCD[11622:1903904] 1------{number = 1, name = main}
2016-09-03 19:29:00.067 GCD[11622:1903904] 1------{number = 1, name = main}
2016-09-03 19:29:00.067 GCD[11622:1903904] 2------{number = 1, name = main}
2016-09-03 19:29:00.067 GCD[11622:1903904] 2------{number = 1, name = main}
2016-09-03 19:29:00.067 GCD[11622:1903904] 3------{number = 1, name = main}
2016-09-03 19:29:00.068 GCD[11622:1903904] 3------{number = 1, name = main}
2016-09-03 19:29:00.068 GCD[11622:1903904] syncSerial---end

1.在串行队列 + 同步执行可以看到，所有任务都是在主线程中执行的，并没有开启新的线程。而且由于串行队列，所以按顺序一个一个执行。
2.同时我们还可以看到，所有任务都在打印的syncConcurrent---begin和syncConcurrent---end之间，这说明任务是添加到队列中马上执行的。

• 串行队列 + 异步执行

会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务

- (void) asyncSerial
{
    NSLog(@"asyncSerial---begin");

    dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);

    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1------%@",[NSThread currentThread]);
        }
    });    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2------%@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"3------%@",[NSThread currentThread]);
        }
    });

    NSLog(@"asyncSerial---end");
}

输出结果为：
2016-09-03 19:30:08.363 GCD[11648:1905817] asyncSerial---begin
2016-09-03 19:30:08.364 GCD[11648:1905817] asyncSerial---end
2016-09-03 19:30:08.364 GCD[11648:1905895] 1------{number = 2, name = (null)}
2016-09-03 19:30:08.364 GCD[11648:1905895] 1------{number = 2, name = (null)}
2016-09-03 19:30:08.364 GCD[11648:1905895] 2------{number = 2, name = (null)}
2016-09-03 19:30:08.364 GCD[11648:1905895] 2------{number = 2, name = (null)}
2016-09-03 19:30:08.365 GCD[11648:1905895] 3------{number = 2, name = (null)}
2016-09-03 19:30:08.365 GCD[11648:1905895] 3------{number = 2, name = (null)}

1.在串行队列 + 异步执行可以看到，开启了一条新线程，但是任务还是串行，所以任务是一个一个执行。
2.另一方面可以看出，所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始同步执行。

三.GCD之间的通讯

在iOS开发过程中，我们一般在主线程里边进行UI刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。

 dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSString * url = @"";
        NSData *imgData = [NSData dataWithContentsOfURL:[NSURL URLWithString:url]];
        UIImage *image = [UIImage imageWithData:imgData];
        
        // 回到主线程
        dispatch_async(dispatch_get_main_queue(), ^{
            [self.imageView setImage:image];
        });
    });

4.GCD 其他用法

• GCD的栅栏方法 dispatch_barrier_async

我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。

- (void)barrier
{
    dispatch_queue_t queue = dispatch_queue_create("12312312", DISPATCH_QUEUE_CONCURRENT);

    dispatch_async(queue, ^{
        NSLog(@"----1-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"----2-----%@", [NSThread currentThread]);
    });

    dispatch_barrier_async(queue, ^{
        NSLog(@"----barrier-----%@", [NSThread currentThread]);
    });

    dispatch_async(queue, ^{
        NSLog(@"----3-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"----4-----%@", [NSThread currentThread]);
    });
}

输出结果：
2016-09-03 19:35:51.271 GCD[11750:1914724] ----1-----{number = 2, name = (null)}
2016-09-03 19:35:51.272 GCD[11750:1914722] ----2-----{number = 3, name = (null)}
2016-09-03 19:35:51.272 GCD[11750:1914722] ----barrier-----{number = 3, name = (null)}
2016-09-03 19:35:51.273 GCD[11750:1914722] ----3-----{number = 3, name = (null)}
2016-09-03 19:35:51.273 GCD[11750:1914724] ----4-----{number = 2, name = (null)}

可以看出在执行完栅栏前面的操作之后，才执行栅栏操作，最后再执行栅栏后边的操作。

• GCD的延时执行方法 dispatch_after

当我们需要延迟执行一段代码时，就需要用到GCD的dispatch_after方法。

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 2秒后异步执行这里的代码...
   NSLog(@"run-----");
});

• GCD的一次性代码(只执行一次) dispatch_once

我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了GCD的dispatch_once方法。使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次。

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    // 只执行1次的代码(这里面默认是线程安全的)
});

• GCD的队列组 dispatch_group

有时候我们会有这样的需求：分别异步执行2个耗时操作，然后当2个耗时操作都执行完毕后再回到主线程执行操作。这时候我们可以用到GCD的队列组。

我们可以先把任务放到队列中，然后将队列放入队列组中。
调用队列组的dispatch_group_notify回到主线程执行操作。

dispatch_group_t group =  dispatch_group_create();

dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 执行1个耗时的异步操作
});

dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 执行1个耗时的异步操作
});

dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    // 等前面的异步操作都执行完毕后，回到主线程...
});

• NSOperation

1.简介

• NSOperation 是对 GCD 的一层封装，更加面向对象。主要由NSOperation（封装操作） 和 NSOperationQueue （队列）实现多线程。

2 .NSOperation

• NSOperation是一个抽象类，不能够封装操作，只能通过以下三种方式来实现封装操作：
• NSInvocationOperation
• NSBlockOperation
• 自定义子类继承 NSOperation ，实现内部相应的方法
• NSInvocationOperation

//创建NSInvocationOperation对象
  NSInvocationOperation *invoOperation = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(doSomeThing) object:nil];
//调用start方法来执行操作
  [invoOperation start];

NSInvocationOperation比较简单，继承了NSOperation，它是基于一个对象和selector来创建操作，可以直接使用而不需继承来实现自己的操作处理。并且默认情况下，调用了start方法之后不会开一条新线程去操作，是在当前线程下同步执行操作，只有将其放到NSOperationQueue中才会执行异步操作。

• NSBlockOperation

//创建NSBlockOperation对象
 NSBlockOperation *blockOperation1 = [NSBlockOperation blockOperationWithBlock:^{
     NSLog(@"create1----%@",[NSThread currentThread]);
 }];

 //通过addExecutionBlock:方法添加更多的操作
 [blockOperation1 addExecutionBlock:^{
     NSLog(@"add1-----%@",[NSThread currentThread]);
 }];

 [blockOperation1 addExecutionBlock:^{
     NSLog(@"add2-----%@",[NSThread currentThread]);
 }];
[blockOperation1 start];

8975FE9D-D470-4860-B22C-E77601139C52.png

可以看出NSBlockOperation如果封装了多个操作，那么除了第一个操作外，其他的操作会在子线程中进行。如果只封装了一个操作，默认在主线程中进行，并且只要NSBlockOperation封装的操作数大于一个，就会异步执行操作。

• 定义继承自NSOperation的子类

//继承NSOpetaion

#import "BHOperation.h"

@implementation BHOperation

- (void)main{
    NSLog(@"%@",[NSThread currentThread]);
}


@end

 BHOperation *operation = [[BHOperation alloc]init];     
 [operation start];

3.NSOperationQueue

• 主队列
• 凡是添加到主队列中的任务（NSOperation），都会放到主线程中执行

NSOperationQueue *queue = [NSOperationQueue mainQueue];

• 其他队列
• 添加到这种队列中的任务（NSOperation），就会自动放到子线程中执行
• 同时包含了：串行、并发功能

NSOperationQueue *queue = [[NSOperationQueue alloc] init];

4.将任务将入到队列中

1.需要先创建任务，再将创建好的任务加入到创建好的队列中去

- (void)addOperationToQueue
{
    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2. 创建操作  
    // 创建NSInvocationOperation    
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];    
    // 创建NSBlockOperation    
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^
            NSLog(@"op1-----%@", [NSThread currentThread]);
    }];

    // 3. 添加操作到队列中：addOperation:   
    [queue addOperation:op1]; // [op1 start]    
    [queue addOperation:op2]; // [op2 start]
}

- (void)run
{
    NSLog(@"op2-----%@", [NSThread currentThread]);
}

2.无需先创建任务，在block中添加任务，直接将任务block加入到队列中。

- (void)addOperationWithBlockToQueue
{
    // 1. 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2. 添加操作到队列中：addOperationWithBlock:
    [queue addOperationWithBlock:^{
            NSLog(@"-----%@", [NSThread currentThread]);
    }];
}

5. 控制串行执行和并行执行的关键

这里有个关键参数maxConcurrentOperationCount，叫做最大并发数。

最大并发数：maxConcurrentOperationCount

• maxConcurrentOperationCount默认情况下为-1，表示不进行限制，默认为并发执行。
• 当maxConcurrentOperationCount为1时，进行串行执行。
• 当maxConcurrentOperationCount大于1时，进行并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整。

6.执行顺序

对于添加到queue中的操作，它的执行顺序取决于两点：

1.首先是NSOperation是否准备好，是否准备好是由对象的依赖关系来决定。

• 操作依赖

NSOperation之间可以设置依赖来保证执行顺序，⽐如一定要让操作A执行完后,才能执行操作B

- (void)addDependency
{
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"1-----%@", [NSThread  currentThread]);
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"2-----%@", [NSThread  currentThread]);
    }];

    [op2 addDependency:op1];    // 让op2 依赖于 op1，则先执行op1，在执行op2

    [queue addOperation:op1];
    [queue addOperation:op2];
}

2.根据NSOperation的相对优先级来决定，默认都是普通的优先级，可以通过setQueuePriority来设置优先级。优先级不能替代依赖关系，优先级是针对于已经准备好的NSOperation来确定执行顺序，先满足依赖关系，再根据优先级从所有准备好的操作中选择执行优先级最高的那个。

• 设置优先级

//创建任务
NSBlockOperation *blockOperation1 = [NSBlockOperation blockOperationWithBlock:^{
      NSLog(@"create1----%@",[NSThread currentThread]);
  }];
//设置优先级
[blockOperation4 setQueuePriority:NSOperationQueuePriorityVeryHigh];
//加入队列
  [myQueue addOperation:blockOperation1];

//优先级:
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
    NSOperationQueuePriorityVeryLow = -8L,
    NSOperationQueuePriorityLow = -4L,
    NSOperationQueuePriorityNormal = 0,
    NSOperationQueuePriorityHigh = 4,
    NSOperationQueuePriorityVeryHigh = 8
};

• （注意）先满足依赖关系，才根据优先级从所有准备好的操作中选择优先级高的执行

7.其他

• -(void)cancel;NSOperation提供的方法，可取消单个操作

• -(void)cancelAllOperations;NSOperationQueue提供的方法，可以取消队列的所有操作

• -(void)setSuspended:(BOOL)b;可设置任务的暂停和恢复，YES代表暂停队列，NO代表恢复队列

• -(BOOL)isSuspended;判断暂停状态

GCD,NSOpeation,NSThread优缺点

• NSThread
  每个NSThread对象对应一个线程，真正最原始的线程。

• 优点：NSThread 轻量级最低，相对简单。

• 缺点：手动管理所有的线程活动，如生命周期、线程同步、睡眠等。

• NSOperation
  自带线程管理的抽象类。

• 优点：自带线程周期管理，操作上可更注重自己逻辑。

• 缺点：面向对象的抽象类，只能实现它或者使用它定义好的两个子类：NSInvocationOperation 和 NSBlockOperation。

• GCD
  Grand Central Dispatch (GCD)是Apple开发的一个多核编程的解决方法。

• 优点：最高效，避开并发陷阱。

• 缺点：基于C实现。

• 选择小结

• 简单而安全的选择NSOperation实现多线程即可。

• 处理大量并发数据，又追求性能效率的选择GCD。

• NSThread本人选择基本上是在做些小测试上使用，当然也可以基于此造个轮子。

参考文献

iOS 多线程基础知识浅析

iOS多线程--彻底学会多线程之『GCD』