1.进程与线程

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是操作系统进行资源分配和调度的一个独立单位。线程是进程的一个实体，是CPU调度和分派的基本单位，是比进程更小的能独立运行的基本单位。任务(task)用于指代抽象的概念,表示需要执行工作，具体可以是一个函数或者一个block。

2.多线程实现方式

• POSIX线程：简称Pthreads，是线程的POSIX标准，该标准定义了创建和操作线程的一套API，是由C语言实现的，例如pthreadcreate()函数可以创建线程，pthreadexit()函数可以终止当前线程，pthreadmutexinit()函数可以初始化互斥锁等等，使用这种方式操作线程需要扎实的C编程功底以及对系统底层工作机制的认识。
• NSThread类：线程，此种方式是轻量级的线程机制，但需要自行管理线程的生命周期，线程同步等问题，同步锁会产生系统开销。
• NSOperationQueue类：执行队列，优点是不需要关心线程管理，数据同步的事情，可以把精力放在线程需要执行的操作上。
• GCD：Grand Central Dispatch，是苹果公司开发的技术，以优化的应用程序支持多核心处理器和其他的对称多处理系统的系统。这建立在任务并行执行的线程池模式的基础上的。它首次发布在Mac OS X 10.6，iOS 4及以上也可以使用，该技术是取代上述技术的技术。

3.NSThread

轻量级最低，相对简单，需要手动管理所有的线程活动（生命周期，休眠，同步等）线程同步对数据的加锁会有一定的系统开销。

(1)创建线程

a.//类方法创建
[NSThread detachNewThreadSelector:(SEL)aSelector toTarget:(id)aTarget withObject:(id)anArgument];
b.//对象方法创建
NSThread *thread = [[NSThread alloc] initWithTarget:(id)aTarget selector:(SEL)aSelector object:(id)anArgument];
[thread start];

(2)线程同步

a.NSLock
b.NSCondition
c.@synchronized代码块

4.NSOperation

自带线程周期管理，可只关注自己处理逻辑
NSOperation是面向对象的抽象类，实现只能是其子类（NSInvocationOperation和NSBlockOperation），对象需要添加到NSOperationQueue队列里执行

a.同步执行
    NSInvocationOperation *operation1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(foo) object:nil];
    [operation1 start];
    NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
       
    }];
    [operation2 start];

b.异步执行
    NSInvocationOperation *operation1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(foo) object:nil];
    NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
        
    }];
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    [queue addOperation:operation1];
    [queue addOperation:operation2];
    //如果需要控制队列中线程的数量，可以使用下面的方式：
    [queue setMaxConcurrentOperationCount:5];

5.GCD

GCD全称为Grand Central Dispatch，是libdispatch的市场名称，而libdispatch是Apple的一个库，其为并发代码在iOS和OS X的多核硬件上执行提供支持。确切地说GCD是一套低层级的C API，通过 GCD，开发者只需要向队列中添加一段代码块(block或C函数指针)，而不需要直接和线程打交道。GCD在后端管理着一个线程池，它不仅决定着你的代码块将在哪个线程被执行，还根据可用的系统资源对这些线程进行管理。这样通过GCD来管理线程，从而解决线程被创建的问题。

异步队列 VS 同步队列

dispatch_async(queue,block) async 异步队列，dispatch_async 函数会立即返回, block会在后台异步执行。 dispatch_sync(queue,block) sync 同步队列，dispatch_sync 函数不会立即返回，及阻塞当前线程,等待 block同步执行完成。

//例：
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSURL * url = [NSURL URLWithString:@"http://image.jpg"];
        NSData * data = [[NSData alloc] initWithContentsOfURL:url];
        UIImage *image = [[UIImage alloc]initWithData:data];
        if (data != nil) {
            dispatch_async(dispatch_get_main_queue(), ^{
                self.imageView.image = image;
            });
        }
    });

串行队列和并行队列

串行队列就是单条线程中，任务挨个处理，主线程本身就是串行队列，一条铁路多个火车排队走。 并行队列就是多条线程，多个任务同时处理，多条铁轨多个火车同时走。

//串行队列
dispatch_queue_t queue = dispatch_queue_create("baobao", DISPATCH_QUEUE_SERIAL);
//并行队列
dispatch_queue_t queue = dispatch_queue_create("baobao", DISPATCH_QUEUE_CONCURRENT);
//系统默认有一条并行队列
dispatch_queue_t globalQ = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//系统默认有一条串行队列
dispatch_queue_t mainQ = dispatch_get_main_queue();

私有队列和全局队列

//私有队列
dispatch_queue_t queue = dispatch_queue_create("baobao", NULL);
//全局队列有且唯一，统一调度，优化资源
dispatch_queue_t globalQ = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

使用队列

// 提交一个block
dispatch_async(queue, ^{
    //...
    dispatch_async(dispatch_get_main_queue(), ^{
        //刷新UI
    });
});
//通常的，无特殊要求的，分线程一律采用global_queue统一调度,优先级无特殊要求的采用Default即可。所谓的优先级分配是指待分配任务中高优先级先行，而对于已进入线程的任务，不会受到后续任务的优先级影响。
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

组任务

(1)dispatch_group_async 可以实现监听一组任务是否完成，完成后得到通知执行其他的操作。这个方法很有用，比如你执行三个下载任务，当三个任务都下载完成后你才通知界面说完成的了。例：

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, queue, ^{
    [NSThread sleepForTimeInterval:3];
    NSLog(@"group1 [NSThread sleepForTimeInterval:3];");
});
dispatch_group_async(group, queue, ^{
    [NSThread sleepForTimeInterval:2];
    NSLog(@"group2 [NSThread sleepForTimeInterval:2];");
});
dispatch_group_async(group, queue, ^{
    [NSThread sleepForTimeInterval:1];
    NSLog(@"group3 [NSThread sleepForTimeInterval:1];");
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    NSLog(@"main thread.");
});
执行结果：
**2017-01-03 10:29:50.128 ****简书****[960:412447] group3 [NSThread sleepForTimeInterval:1];**
**2017-01-03 10:29:51.130 ****简书****[960:412448] group2 [NSThread sleepForTimeInterval:2];**
**2017-01-03 10:29:52.128 ****简书****[960:412450] group1 [NSThread sleepForTimeInterval:3];**
**2017-01-03 10:29:52.129 ****简书****[960:412106] main thread.**

(2)dispatch_barrier_async是在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行，例：

dispatch_queue_t queue = dispatch_queue_create("baobao", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:3];
    NSLog(@"dispatch_async1");
});

dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:3];
    NSLog(@"dispatch_async2");
});
dispatch_barrier_async(queue, ^{
    NSLog(@"dispatch_barrier_async");
    [NSThread sleepForTimeInterval:1];
});
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:3];
    NSLog(@"dispatch_async3");
});
执行结果：
**2017-01-03 10:36:38.500 ****简书****[1033:454725] dispatch_async2**
**2017-01-03 10:36:38.500 ****简书****[1033:454746] dispatch_async1**
**2017-01-03 10:36:38.500 ****简书****[1033:454746] dispatch_barrier_async**
**2017-01-03 10:36:42.511 ****简书****[1033:454746] dispatch_async3**
//如果使用dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
执行结果：
**2017-01-03 10:39:45.198 ****简书****[1059:477846] dispatch_barrier_async**
**2017-01-03 10:39:48.199 ****简书****[1059:477847] dispatch_async2**
**2017-01-03 10:39:48.199 ****简书****[1059:477849] dispatch_async1**
**2017-01-03 10:39:48.199 ****简书****[1059:477894] dispatch_async3**
//说明dispatch_barrier_async的顺序执行还是依赖queue的类型，必需要queue的类型为dispatch_queue_create创建的，而且attr参数值必需是DISPATCH_QUEUE_CONCURRENT类型，前面两个非dispatch_barrier_async的类型的执行是依赖其本身的执行时间的，如果attr如果是DISPATCH_QUEUE_SERIAL时，那就完全是符合Serial queue的FIFO特征了。

线程批处理

dispatch_apply的作用是在一个队列（串行或并行）上“运行”多次block，其实就是简化了用循环去向队列依次添加block任务。

//创建异步串行队列
dispatch_queue_t queue = dispatch_queue_create("baobao", DISPATCH_QUEUE_SERIAL);
//运行block3次
dispatch_apply(3, queue, ^(size_t i) {
    NSLog(@"apply loop: %zu", i);
});
 NSLog(@"After apply");
执行结果：
**2017-01-03 10:46:59.132 ****简书****[1088:522375] apply loop: 0**
**2017-01-03 10:46:59.133 ****简书****[1088:522375] apply loop: 1**
**2017-01-03 10:46:59.133 ****简书****[1088:522375] apply loop: 2**
**2017-01-03 10:46:59.133 ****简书****[1088:522375] After apply**

dispatch_once函数

保证整个应用程序生命周期中某段代码只被执行一次！dispatch_once_t必须是全局或static变量，非全局或非static的dispatch_once_t变量在使用时会产生BUG

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
        
});

挂起和恢复队列

dispatch_queue_t queue = dispatch_queue_create("baobao", DISPATCH_QUEUE_SERIAL);
//提交第一个block，延时3秒打印。
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:3];
    NSLog(@"After 3 seconds...");
});
//提交第二个block，也是延时3秒打印
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:3];
    NSLog(@"After 3 seconds again...");
});
//延时一秒
NSLog(@"sleep 1 second...");
[NSThread sleepForTimeInterval:1];
//挂起队列
NSLog(@"suspend...");
dispatch_suspend(queue);
//延时5秒
NSLog(@"sleep 5 second...");
[NSThread sleepForTimeInterval:5];
//恢复队列
NSLog(@"resume...");
dispatch_resume(queue);
//执行结果：
**2017-01-03 10:59:51.390 ****简书****[1123:585605] sleep 1 second...**
**2017-01-03 10:59:52.391 ****简书****[1123:585605] suspend...**
**2017-01-03 10:59:52.392 ****简书****[1123:585605] sleep 5 second...**
**2017-01-03 10:59:54.395 ****简书****[1123:585650] After 3 seconds...**
**2017-01-03 10:59:57.393 ****简书****[1123:585605] resume...**
**2017-01-03 11:00:00.393 ****简书****[1123:585650] After 3 seconds again...**