在IOS中为什么使用多线程及多线程实现的三种方法

多线程是一个比较轻量级的方法来实现单个应用程序内多个代码执行路径。

在系统级别内，程序并排执行，程序分配到每个程序的执行时间是基于该程序的所需时间和其他程序的所需时间来决定的。

然而，在每个程序内部，存在一个或者多个执行线程，它同时或在一个几乎同时发生的方式里执行不同的任务。

概要提示：

iphone中的线程应用并不是无节制的，官方给出的资料显示，iphone os下的主线程的堆栈大小是1m，第二个线程开始就是512kb，并且该值不能通过编译器开关或线程api函数来更改，只有主线程有直接修改ui的能力

一、线程概述

有些程序是一条直线，起点到终点——如简单的hello world，运行打印完，它的生命周期便结束了，像是昙花一现。

有些程序是一个圆，不断循环直到将它切断——如操作系统，一直运行直到你关机。

一个运行着的程序就是一个进程或者叫做一个任务，一个进程至少包含一个线程，线程就是程序的执行流。

mac和ios中的程序启动，创建好一个进程的同时，一个线程便开始运作，这个线程叫做主线程。主线成在程序中的位置和其他线程不同，它是其他线程最终的父线程，且所有的界面的显示操作即appkit或uikit的操作必须在主线程进行。

系统中每一个进程都有自己独立的虚拟内存空间，而同一个进程中的多个线程则公用进程的内存空间。

每创建一个新的进成，都需要一些内存（如每个线程有自己的stack空间）和消耗一定的cpu时间。

当多个进成对同一个资源出现争夺的时候需要注意线程安全问题

创建线程

创建一个新的线程就是给进程增加一个执行流，所以新建一个线程需要提供一个函数或者方法作为线程的进口。

1.使用nsthread

nsthread提供了创建线程的路径，还可以提供了监测当前线程是否是主线程的方法使用nsthread创建一个新的线程有两种方式：

1.创建一个nsthread的对象，调用start方法——使用一个目标对象的方法初始化一个nsthread对象，或者创建一个继承自nsthread的子类，实现起main方法？，然后在直接创建这个子类的对象。

2.使用detachnewthreadselector：totarget：withobject：这个类方法创建一个子线程，这个比较直接，直接使用目标对象的方法作为线程启动入口

2.使用nsobject

使用nsobject直接就加入了对多线程的支持，允许对象的某个方法在后台运行。

[my0bj performselectorinbackground:@selector（dosomething） withobject:nil];

3.posix thread

由于mac和ios都是基于darwin系统，darwin系统的unx内核，是基于mach和bsd的，继承了bsd的posix接口，所以可以直接使用posix线程的相关接口开实现线程
创建线程的接口为 pthread_create, 当然在创建线程之前可以创建好相关线程的属性

——————————————————————————————————————

nsoperation&nsoperationqueue

很多时候我们使用多线程，需要控制线程的并发数，毕竟线程也是需要消耗系统资源的，当程序中同时运行的线程过多时，系统必然变慢，所以很多时候我们会控制同时运行线程的数目
nsoperation可以封装我们的操作，然后将创建好的nsoperation对象放到nsoperationqueue队列中，operationqueue便开始启动新的线程去执行队列中的操作，operationqueue的并发数时可以通过如下方式进行设置的：

- (void)setmaxconcurrentoperationcount:(nsinteger)count

gcd时grand central dispatch的缩写，是一系列bsd层面的接口。在mac10.6和ios4.0以后才引入的且现在nsoperation和nsoperationqueue的多线程的实现就是基于gcd的。目前这个特性也被移植到 freebsd上了，可以查看libdispatch这个开源项目。

dispatch_queue_t imagedownloadqueue = dispatch_get_global_queue(dispatch_queue_priority_default, 0);

当然，gcd除了处理多线程外还有很多非常好的功能，其建立在强大的kqueue之上，效率也能够得到保障。

前言

在多线程简介中，我已经说明过了，为了提高界面的流畅度以及用户体验。我们务必要把耗时的操作放到别的线程中去执行，千万不要阻塞主线程。

下面小编给大家带来三种ios多线程编程方法：

nsthread
grand centeral dispatch(gcd)
nsoperation和nsoperationqueue

1.nsthread

这是最轻量级的多线程的方法，使用起来最直观的多线程编程方法。但是因为需要自己管理线程的生命周期，线程同步。经常使用nsthread进行调试，在实际项目中不推荐使用。

//获取当前线程
nsthread *current = [nsthread currentthread];
//获取主线程
nsthread *main = [nsthread mainthread];
nslog(@"当前线程 --- %@",current);
nslog(@"主线程 --- %@",main);

控制台输出结果：

2015-11-22 22:30:29.572 多线程demo[1289:2925847] 当前线程 --- <nsthread: 0x7fc0e1401dc0>{number = 1, name = main}
2015-11-22 22:30:29.572 多线程demo[1289:2925847] 主线程 --- <nsthread: 0x7fc0e1401dc0>{number = 1, name = main}

从结果我们看出当前的线程就是主线程， number 相当于线程的id, name 是线程的名称,主线程的number就是1

阻塞线程：

//阻塞线程3秒
[nsthread sleepfortimeinterval:3];
[nsthread sleepuntildate:[nsdate datewithtimeintervalsincenow:3]];

2.gcd(grand central dispatch)

gcd是基于c语言底层api实现的一套多线程并发机制，非常的灵活方便，在实际的开发中使用很广泛。

简单来说cgd就是把 操作 放在 队列 中去执行。

你只需定义好操作和队列就可以了，不需要直接控制线程的创建和销毁，线程的生命周期由队列来管理。

队列：负责操作的调度和执行，有先进先出(fifo)的特点。也就是说先加入队列的操作先执行，后加入的后执行。

队列有两种：

串行队列：

队列中的操作只会按顺序执行，你可以想象成单窗口排队。

并行队列：

队列中的操作可能会并发执行，这取决与操作的类型，你可以想象成多窗口排队。

//创建串行队列
dispatch_queue_t q = dispatch_queue_create("my_serial_queue", dispatch_queue_serial);
//创建并行队列
dispatch_queue_t q = dispatch_queue_create("my_concurrent_queue", dispatch_queue_concurrent);

my_serial_queue和my_concurrent_queue是队列的名字标签，为了与其他的队列区分，在一个项目里面必须是唯一的。

dispatch_queue_serial表示串行队列

dispatch_queue_concurrent表示并行队列

操作同样也分两种类型：

同步操作：只会按顺序执行，执行顺序是确定的。

异步操作：在串行队列中执行顺序确定，在并行队列中执行顺序不确定

使用block来定义操作要执行的代码，q是已经定义好的，操作要加入的队列

//定义同步操作
dispatch_sync(q, ^{
 //要执行的代码 
});
//定义异步操作
dispatch_async(q, ^{
 //要执行的代码  
});

下面我们看一下同步，异步操作加入到串行和并行队列里面，执行的顺序和特点：1.同步操作不管加入到何种队列，只会在主线程按顺序执行

dispatch_queue_t q_serial = dispatch_queue_create("my_serial_queue", dispatch_queue_serial);
dispatch_queue_t q_concurrent = dispatch_queue_create("my_concurrent_queue", dispatch_queue_concurrent);
for (int i = 0; i < 5; ++i) {
 dispatch_sync(q_serial, ^{
 nslog(@"串行队列里的同步任务 %@ %d", [nsthread currentthread], i);
 });
}
for (int i = 0; i < 5; ++i) {
 dispatch_sync(q_concurrent, ^{
 nslog(@"并行队列里的同步任务 %@ %d", [nsthread currentthread], i);
 });
}

下面是控制台输出结果：

2015-11-23 00:40:36.862 01.gcd演练[1952:3613752] 串行队列里的同步任务 <nsthread: 0x7ff833505450>{number = 1, name = main} 0
2015-11-23 00:40:36.863 01.gcd演练[1952:3613752] 串行队列里的同步任务 <nsthread: 0x7ff833505450>{number = 1, name = main} 1
2015-11-23 00:40:36.863 01.gcd演练[1952:3613752] 串行队列里的同步任务 <nsthread: 0x7ff833505450>{number = 1, name = main} 2
2015-11-23 00:40:36.863 01.gcd演练[1952:3613752] 串行队列里的同步任务 <nsthread: 0x7ff833505450>{number = 1, name = main} 3
2015-11-23 00:40:36.863 01.gcd演练[1952:3613752] 串行队列里的同步任务 <nsthread: 0x7ff833505450>{number = 1, name = main} 4
2015-11-23 00:40:36.863 01.gcd演练[1952:3613752] 并行队列里的同步任务 <nsthread: 0x7ff833505450>{number = 1, name = main} 0
2015-11-23 00:40:36.863 01.gcd演练[1952:3613752] 并行队列里的同步任务 <nsthread: 0x7ff833505450>{number = 1, name = main} 1
2015-11-23 00:40:36.863 01.gcd演练[1952:3613752] 并行队列里的同步任务 <nsthread: 0x7ff833505450>{number = 1, name = main} 2
2015-11-23 00:40:36.864 01.gcd演练[1952:3613752] 并行队列里的同步任务 <nsthread: 0x7ff833505450>{number = 1, name = main} 3
2015-11-23 00:40:36.864 01.gcd演练[1952:3613752] 并行队列里的同步任务 <nsthread: 0x7ff833505450>{number = 1, name = main} 4

2.异步操作只在非主线程的线程执行，在串行队列中异步操作会在新建的线程中按顺序执行。

 dispatch_queue_t q_serial = dispatch_queue_create("my_serial_queue", dispatch_queue_serial);
 for(int i = 0; i < 5; ++i){
  dispatch_async(q_serial, ^{
   nslog(@"串行队列 -- 异步任务 %@ %d", [nsthread currentthread], i);
  });
 }

因为是异步操作，所以会新建一个线程。又因为加入到串行队列中，所以所有的操作只会按顺序执行。

2015-11-23 01:03:22.372 01.gcd演练[2081:3627139] 串行队列 -- 异步任务 <nsthread: 0x7fb593d42f50>{number = 2, name = (null)} 0
2015-11-23 01:03:23.373 01.gcd演练[2081:3627139] 串行队列 -- 异步任务 <nsthread: 0x7fb593d42f50>{number = 2, name = (null)} 1
2015-11-23 01:03:24.374 01.gcd演练[2081:3627139] 串行队列 -- 异步任务 <nsthread: 0x7fb593d42f50>{number = 2, name = (null)} 2
2015-11-23 01:03:25.375 01.gcd演练[2081:3627139] 串行队列 -- 异步任务 <nsthread: 0x7fb593d42f50>{number = 2, name = (null)} 3
2015-11-23 01:03:26.376 01.gcd演练[2081:3627139] 串行队列 -- 异步任务 <nsthread: 0x7fb593d42f50>{number = 2, name = (null)} 4

3.异步操作，并行队列

 dispatch_queue_t q_concurrent = dispatch_queue_create("my_concurrent_queue", dispatch_queue_concurrent);
 for(int i = 0; i < 5; ++i){
  dispatch_async(q_concurrent, ^{
   nslog(@"并行队列 -- 异步任务 %@ %d", [nsthread currentthread], i);
  });
 }

理论上并行队列会给每一个异步操作新建线程，然后让所有的任务并发执行。但是实际上系统能创建的线程数量是有限的，当创建的线程达到最大线程数以后，后面的异步操作就需要等待前面的操作执行完毕才能得到执行。哪个线程操作执行完毕，就把等待的异步任务安排到哪个线程。直到所有的操作执行完毕。你可以把上述代码的循环次数改成5000就可以观察到此现象。

2015-11-23 01:14:15.282 01.gcd演练[2165:3634728] 并行队列 -- 异步任务 <nsthread: 0x7fb3b841b0a0>{number = 4, name = (null)} 3
2015-11-23 01:14:15.282 01.gcd演练[2165:3634724] 并行队列 -- 异步任务 <nsthread: 0x7fb3b8514da0>{number = 3, name = (null)} 0
2015-11-23 01:14:15.282 01.gcd演练[2165:3634726] 并行队列 -- 异步任务 <nsthread: 0x7fb3b8604db0>{number = 5, name = (null)} 2
2015-11-23 01:14:15.282 01.gcd演练[2165:3634725] 并行队列 -- 异步任务 <nsthread: 0x7fb3b86119d0>{number = 2, name = (null)} 1
2015-11-23 01:14:15.285 01.gcd演练[2165:3634729] 并行队列 -- 异步任务 <nsthread: 0x7fb3b87011f0>{number = 6, name = (null)} 4

3.nsoperation & nsoperationqueue

虽然gcd的功能已经很强大了，但是它使用的api依然是c语言的。在某些时候，在面向对象的objective-c中使用起来非常的不方便和不安全。

所以苹果公司把gcd中的操作抽象成nsoperation对象，把队列抽象成nsoperationqueue对象。

抽象为nsoperation & nsoperationqueue以后的好处有一下几点：

代码风格统一了，我们不用在面向对象的objective-c中写面对过程的c语言代码了。
我们知道在gcd中操作的执行代码都是写在匿名的block里面，那么我们很难做到给操作设置依赖关系以及取消操作。这些功能都已经封装到nsoperation对象里面了。^-^
nsoperationqueue对象比gcd中队列更加的强大和灵活，比如：设置并发操作数量，取消队列中所有操作。
nsoperation分为nsinvocationoperation和nsblockoperation

nsinvocationoperation的使用

//首先定义一个nsoperationqueue对象
nsoperationqueue *queue = [[nsoperationqueue alloc] init];
nsinvocationoperation *op = [[nsinvocationoperation alloc] initwithtarget:self selector:@selector(operationaction:) object:@"这里可以穿参数"];
[queue addoperation:op];//把操作加入队列中即开始执行
- (void)operationaction:(id)obj
{
 nslog(@"%@ - obj : %@", [nsthread currentthread], obj);
}

输出为：

2015-11-23 02:55:19.067 多线程demo[2604:3686934] <nsthread: 0x7f9dfa443510>{number = 2, name = (null)} - obj : 这里可以穿参数

nsblockoperation的使用

nsoperationqueue *queue = [[nsoperationqueue alloc] init];
nsblockoperation *op = [nsblockoperation blockoperationwithblock:^{
 [self operationaction:@"这是nsblockoperation"];
}];
[queue addoperation:op];

输出为：

2015-11-23 02:56:11.812 多线程demo[2617:3687872] <nsthread: 0x7fa983f10a50>{number = 2, name = (null)} - obj : 这是nsblockoperation

设置依赖关系(执行顺序)

 nsoperationqueue *queue = [[nsoperationqueue alloc] init];
 nsinvocationoperation *op1 = [[nsinvocationoperation alloc] initwithtarget:self selector:@selector(operationaction:) object:@"op1"];
 nsinvocationoperation *op2 = [[nsinvocationoperation alloc] initwithtarget:self selector:@selector(operationaction:) object:@"op2"];
 //op2在op1之后执行
 [op2 adddependency:op1];//这里需要注意，一定要在addoperation之前设置依赖关系 
 [queue addoperation:op1];
 [queue addoperation:op2];

输出为：

2015-11-23 02:57:40.283 多线程demo[2661:3689737] <nsthread: 0x7fb663e132d0>{number = 2, name = (null)} - obj : op1
2015-11-23 02:57:40.284 多线程demo[2661:3689737] <nsthread: 0x7fb663e132d0>{number = 2, name = (null)} - obj : op2

没有设置依赖关系的输出：

2015-11-23 03:00:45.939 多线程demo[2709:3692307] <nsthread: 0x7fe951d0d8a0>{number = 2, name = (null)} - obj : op2
2015-11-23 03:00:45.939 多线程demo[2709:3692308] <nsthread: 0x7fe951c24720>{number = 3, name = (null)} - obj : op1

到这里你应该发现了，在nsoperation & nsoperationqueue中，我们不需要再像gcd那样定义操作的类型和队列的类型和控制操作的执行顺序了，你只需要直接设定操作的执行顺序就可以了。