iOS 多线程

什么是进程

在系统中正在运行的一个应用程序。

每个进程之间是独立的，每个进程均运行在其专用而且受保护的内存空间内。

什么是线程

一个进程要想执行任务，必须得有一个线程，而且每一个进程中至少有一个线程

进程的所有任务都在线程中执行

多线程原理

1、同一时间，CPU只能处理一条线程，只有一条线程在工作

2、多线程并发，其实是CPU快速的在多条线程之间切换

3、如果多线程切换速度特别快，就造成了多线程并发执行的假象

**注：**如果线程非常多，CPU会在N多线程之间切换，CPU消耗就会特别大，每条线程被调用额频率就会被降低，所有要适当使用多线程

多线程优缺点

优点

1、能适当的提高程序执行效率

2、能够适当的提高资源利用率（CPU，内存利用率）

缺点

1、创建线程是有开销的，iOS下主要成本包括：内核数据结构（大约1KB），栈空间（子线程512KB，主线程1MB，也可以使用-setStackSize：设置，但是必须是4K的倍数，而且最小是16K），创建线程大约需要90毫秒的创建时间

2、若开启大量线程，会降低线程上的性能，CPU消耗越大

3、多线程使用太多，会使程序设计更加复杂，比如线程间的通信，数据共享等

多线程的对比

多线程

一、关于NSThread

通过alloc init进行创建

//创建线程

NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector(run:) object:@"jack"];

thread.name = @"my-thread";

thread.threadPriority = 0.1;

//启动线程

[thread start];

通过 detachNewThreadSelector 方式创建并执行线程

[NSThread detachNewThreadSelector:@selector(run:) toTarget:self withObject:@"rose"];

隐式创建后自动启动线程

[self performSelectorInBackground:@selector(run:) withObject:@"wahaha"];

采用第一种方式：设置一些线程属性；例如线程 名字，从控制台信息可以看出来，当设置了不同的NSThread对象的优先级属性，可以控制其执行的顺序，优先级越高，越先执行；而设置名字属性后，可以通过调试监控当前所处线程，便于问题分析

第二、三种，创建和操作简单

多线程的竞争（线程锁）

一块资源可能被多个线程共享，也就是多个线程可能会访问同一个资源、同一个对象、同一个变量，就会出现线程安全问题

lock示例

当线程A去访问文件时，需要将文件锁住，读取并运算结束后，将其解锁，线程B再去访问，线程B访问时需要再次将文件加锁并运算，结束后再解锁。这样就避免了俩个线程同时访问文件而造成文件错误。

互斥锁使用

格式：@synchronized(锁对象) { // 需要锁定的代码 }

**互斥锁的使用前提：**多条线程抢夺同一块资源

**注意：**锁定1份代码只用1把锁，用多把锁是无效的

互斥锁的优缺点

优点：能有效防止因多线程抢夺资源造成的数据安全问题

缺点：需要消耗大量的CPU资源

线程同步

线程同步的意思是：多条线程在同一条线上执行（按顺序地执行任务）

互斥锁，就是使用了线程同步技术，保证线程的串行

线程异步

多线程默认的就是异步，这个不需要多做解释

原子和非原子属性

atomic：原子属性，默认为setter方法加锁（默认就是atomic），线程安全，需要消耗大量的资源

nonatomic：非原子属性，不会为setter方法加锁，适合内存小的移动设备

注：iOS开发中，所有属性都声明为nonatomic，尽量避免多线程抢夺同一资源。尽量将加锁，资源抢夺业务交给服务器

线程间通信

在一个进程中，线程往往不是孤立存在，多个线程需要经常进行通信，一般表现为一个线程传递数据给另外一个线程，或者在一个线程中执行完一个特定任务后，转到另一个线程继续执行任务

线程间通信常用方法

- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;

- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait;

示例：处理UI在主线程，下载图片载子线程，当图片下载完后，回归主线程并显示

线程通信

- (IBAction)showImageView:(UIButton *)sender {

    NSLog(@"%@",[NSThread currentThread]);

    [self performSelectorInBackground:@selector(download) withObject:nil];

}

-(void)download{

    NSURL *url = [NSURL URLWithString:@"http://img.pconline.com.cn/images/photoblog/9/9/8/1/9981681/200910/11/1255259355826.jpg"];

    NSData *data = [NSData dataWithContentsOfURL:url];

    UIImage *image =[UIImage imageWithData:data];

    NSLog(@"%@",[NSThread currentThread]);

    [self performSelectorOnMainThread:@selector(showImage:) withObject:image waitUntilDone:YES];

}

-(void)showImage:(UIImage *)image{

    self.imageView.image = image;

    NSLog(@"%@",[NSThread currentThread]);

}

二、关于GCD

GCD的内部实现

1、iOS和OS的内核是XNU内核，GCD是基于XNU内核实现的

2、GCD的API全部在libdispatch库中

3、GCD的底层实现主要有Dispatch Queue（管理block<操作>）和Dispatch Source（处理事件<比如线程间的通信>）

GCD优势

CGD是苹果公司为多核的并行运算提供的方案（iOS4开始）

GCD会自动利用更多的CPU内核

GCD会自动管理线程生命周期（创建线程、调度线程、销毁线程）程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理的代码

GCD俩个核心概念

任务：执行什么操作

队列：用来存放任务

GCD使用

定制任务（想做的操作）

将任务添加到队列当中（GCD会自动将队列中的任务取出，放到对应的线程中执行，任务的取出遵循队列的FIFO原则，先进先出，后进后出。）

GCD执行

//同步方式执行

dispatch_sync(dispatch_queue_t  _Nonnull queue, <^(void)block>)

//异步的方式执行

dispatch_async(dispatch_queue_t  _Nonnull queue, <^(void)block>)

queue：队列

block：任务

同步和异步的区别：

同步：只能在当前线程中执行任务，不具备开启新线程的能力

异步：可以在新的线程中执行任务，具备开启新线程的能力

GCD的队列类型

并发队列：可以让多个任务并发执行，并发功能只有在异步dispatch_async函数下才有效

串行队列：让任务一个接着一个地执行

注：有四个容易混淆的概念：同步、异步、并发、串行

同步和异步主要影响能不能开线程

串行和并行主要影响任务的执行方式

各种队列的执行效果

GCD

注：1、使用同步函数往当前串行队列中添加任务，会卡住当前的串行队列

2、使用异步函数是需要把当前方法执行，再去执行异步函数

GCD线程间通信

//图片子线程下载dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        NSURL *url = [NSURL URLWithString:@"http://img.pconline.com.cn/images/photoblog/9/9/8/1/9981681/200910/11/1255259355826.jpg"];

        NSData *data = [NSData dataWithContentsOfURL:url];

        UIImage *image =[UIImage imageWithData:data];

        //图片主线程显示

        dispatch_sync(dispatch_get_main_queue(), ^{

            self.imageView.image = image;

        });

    });

三、关于NSOperation

配合使用NSOperation和NSOperationQueue也能实现多线程编程

1.先将需要执行的操作封装到一个NSOperation对象中

2.然后将NSOperation对象添加到NSOperationQueue中

3.系统会自动将NSOperationQueue中的NSOperation取出来

4.将取出的NSOperation封装的操作放到一条新线程中执行

NSOperation的子类（抽象类，并不具备封装操作的能力，必须使用它的子类）

1.NSInvocationOperation

2.NSBlockOperation

3.自定义子类继承NSOperation,实现内部相应的方法

关于NSInvocationOperation

调用start方法开始执行操作，一旦执行操作就会调用run方法

注：默认情况下，调用了start方法后并不会开一条新线程去执行操作，而是在当前线程同步执行操作

只有NSOperation放到一个NSOperationQueue中，才会异步执行

- (IBAction)invocationOperation:(id)sender {

    //初始化Operation子类

    NSInvocationOperation *operation = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(run) object:nil];

    //开启

    [operation start];

}

-(void)run{

    NSLog(@"0--%@",[NSThread currentThread]);

}

注：只要NSBlockOperation封装的操作数大于1，就会异步执行

//初始化Operation子类

    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{

        NSLog(@"1--%@",[NSThread currentThread]);

    }];

    //添加额外的任务（在子线程执行）

    [operation addExecutionBlock:^{

        NSLog(@"2--%@",[NSThread currentThread]);

    }];

    [operation addExecutionBlock:^{

        NSLog(@"3--%@",[NSThread currentThread]);

    }];

    [operation start];

NSOperationQueue设置队列监听与依赖

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

    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{

        NSLog(@"down1---%@",[NSThread currentThread]);

    }];

    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{

        NSLog(@"down2---%@",[NSThread currentThread]);

    }];

    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{

        NSLog(@"down3---%@",[NSThread currentThread]);

    }];

    NSBlockOperation *op4 = [NSBlockOperation blockOperationWithBlock:^{

        NSLog(@"down4---%@",[NSThread currentThread]);

    }];

    //设置依赖（op1和op3执行完之后才执行2）

    [op3 addDependency:op1];

    [op3 addDependency:op4];

    [queue addOperation:op1];

    [queue addOperation:op2];

    [queue addOperation:op3];

    [queue addOperation:op4];

    //监听一个操作的执行完成

    [op3 setCompletionBlock:^{

        NSLog(@"执行完成");

    }];

注：一定要避免相互依赖，比如

[op3 addDependency:op1];

[op1 addDependency:op3];    //错误的写法---相互依赖

NSOperationQueue队列间的数据通信

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

    __block UIImage *image1;

    NSBlockOperation *downloadw1 = [NSBlockOperation blockOperationWithBlock:^{

        //下载图片1

        NSURL *url = [NSURL URLWithString:@"http://img.pconline.com.cn/images/photoblog/9/9/8/1/9981681/200910/11/1255259355826.jpg"];

        NSData *data = [NSData dataWithContentsOfURL:url];

        image1 =[UIImage imageWithData:data];

    }];

    __block UIImage *image2;

    NSBlockOperation *downloadw2 = [NSBlockOperation blockOperationWithBlock:^{

        //下载图片2

        NSURL *url = [NSURL URLWithString:@"http://pic38.nipic.com/20140228/5571398_215900721128_2.jpg"];

        NSData *data = [NSData dataWithContentsOfURL:url];

        image2 =[UIImage imageWithData:data];

    }];

    NSBlockOperation *combine = [NSBlockOperation blockOperationWithBlock:^{

        //合成新图片

        UIGraphicsBeginImageContext(CGSizeMake(100, 100));

        [image1 drawInRect:CGRectMake(0, 0, 50, 100)];

        [image2 drawInRect:CGRectMake(50, 0, 50, 100)];

        UIImage *image = UIGraphicsGetImageFromCurrentImageContext();

        UIGraphicsEndImageContext();

        [[NSOperationQueue mainQueue]addOperationWithBlock:^{

            self.imageView.image = image;

        }];

    }];

    [combine addDependency:downloadw1];

    [combine addDependency:downloadw2];

    [queue addOperation:downloadw1];

    [queue addOperation:downloadw2];

    [queue addOperation:combine];