ios多线程使用

多线程编程大家肯定不陌生，关于ios多线程的使用的相关技术文章太多，本篇文章也是主要参考部分文章来进行关于ios多线程使用的总结。
首先我们看下，本篇文章提到的主要知识要点。

屏幕快照 2017-12-28 上午8.28.49.png

一.概念

1.进程

1.进程是一个具有一定独立功能的程序关于某次数据集合的一次运行活动，它是操作系统分配资源的基本单元.
2.进程是指在系统中正在运行的一个应用程序，就是一段程序的执行过程,我们可以简单理解为手机程序上的一个app.

2.线程

1.程序执行流的最小单元，线程是进程中的一个实体.
2.一个进程要想执行任务,必须要有线程,至少有一条线程.其实应用程序启动的时候我们的系统就会默认帮我们的应用程序开启一条线程,这条线程也叫做'主线程',或者'UI线程'

3.进程和线程的关系

1.线程是进程的执行单元，进程的所有任务都在线程中执行！
2.线程是 CPU 调用的最小单位
3.进程是 CPU 分配资源和调度的单位
4.一个程序可以对应过个进程,一个进程中可有多个线程,但至少要有一条线程
5.同一个进程内的线程共享进程资源

4.同步

只能在当前线程按先后顺序依次执行，不开启新线程。

5.异步

 可以在当前线程开启多个新线程执行，可不按顺序执行。

补充，其实同步和异步，就是一个消息机制的概念。

同步和异步关注的是消息通信机制。具体说来，同步是发出一个调用后，在没有得到结果之前，该调用不返回；而异步是发出一个调用后，直接返回，并不立刻得到结果。
是不是很难理解，举个栗子就好理解了。

1.同步就是你叫我去吃饭，我听到了就和你去吃饭；如果没有听到，你就不停的叫，直到我告诉你听到了，才一起去吃饭。

2.异步就是你叫我，然后自己去吃饭，我得到消息后可能立即走，也可能等到下班才去吃饭。

6.队列

装载线程任务的队形结构。

7.并发

线程执行可以同时一起进行执行。

8.串行

 线程执行只能依次逐一先后有序的执行。

二.ios多线程对比

1.operation补充依赖

1. NSThread

每个NSThread对象对应一个线程，真正最原始的线程。
1.优点：NSThread 轻量级最低，相对简单。
2.缺点：手动管理所有的线程活动，如生命周期、线程同步、睡眠等。

2. NSOperation

自带线程管理的抽象类。
1.优点：自带线程周期管理，操作上可更注重自己逻辑。
2.缺点：面向对象的抽象类，只能实现它或者使用它定义好的两个子类：NSInvocationOperation 和 NSBlockOperation。

3. GCD

Grand Central Dispatch (GCD)是Apple开发的一个多核编程的解决方法。
1.优点：最高效，避开并发陷阱。
2.缺点：基于C实现。

4. 选择小结

1.简单而安全的选择NSOperation实现多线程即可。
2.处理大量并发数据，又追求性能效率的选择GCD。
3.NSThread本人选择基本上是在做些小测试上使用，当然也可以基于此造个轮子。

四.使用方法

1.NSThread

//动态创建线程
-(void)dynamicCreateThread{
    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(loadImageSource:) object:imgUrl];
    thread.threadPriority = 1;// 设置线程的优先级(0.0 - 1.0，1.0最高级)
    [thread start];
}

//静态创建线程
-(void)staticCreateThread{
    [NSThread detachNewThreadSelector:@selector(loadImageSource:) toTarget:self withObject:imgUrl];
}

//隐式创建线程
-(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(@"there no image data");
    }
}

-(void)refreshImageView:(UIImage *)image{
    [self.imageView setImage:image];
}

补充知识点

NSThread *current = [NSThread currentThread];   //获取当前线程
NSThread *main = [NSThread mainThread];    //获取主线程
[NSThread sleepForTimeInterval:2];  //暂停等待线程，也就是我们通常所说的延迟执行2秒
//在指定线程上执行操作
[self performSelector:@selector(run) onThread:thread withObject:nil waitUntilDone:YES]; 
//在主线程上执行操作
[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:YES]; 
//在当前线程执行操作
[self performSelector:@selector(run) withObject:nil];

2.NSOperation

主要的实现方式：结合NSOperation和NSOperationQueue实现多线程编程。

1.实例化NSOperation的子类，绑定执行的操作。
2.创建NSOperationQueue队列，将NSOperation实例添加进来。
3.系统会自动将NSOperationQueue队列中检测取出和执行NSOperation的操作

代码的主要实现方法

//使用子类NSInvocationOperation
-(void)useInvocationOperation{
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(loadImageSource:) object:imgUrl];
    //[invocationOperation start];//直接会在当前线程主线程执行
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    [queue addOperation:invocationOperation];
    
}

//使用子类NSBlockOperation
-(void)useBlockOperation{
    
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        [self loadImageSource:imgUrl];
    }];
    
    NSBlockOperation *blockOperation1 = [NSBlockOperation blockOperationWithBlock:^{
        // 代码操作1
    }];
    NSBlockOperation *blockOperation2 = [NSBlockOperation blockOperationWithBlock:^{
        // 代码操作2
    }];
    NSBlockOperation *blockOperation3 = [NSBlockOperation blockOperationWithBlock:^{
        // 代码操作3
    }];
    /*
     
     // 添加操作之间的依赖关系，所谓“依赖”关系，就是等待前一个任务完成后，后一个任务才能启动
     
     // 依赖关系可以跨线程队列实现
     
     // 提示：在指定依赖关系时，注意不要循环依赖，否则不工作。
     
     */
    [blockOperation1 addDependency:blockOperation];
    [blockOperation2 addDependency:blockOperation1];
    [blockOperation3 addDependency:blockOperation2];
    
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    [queue addOperation:blockOperation];
    [queue addOperation:blockOperation1];
    [queue addOperation:blockOperation2];
    [queue addOperation:blockOperation3];
    [queue setMaxConcurrentOperationCount:2];// 控制同时最大并发的线程数量

}
//使用继承NSOperation
-(void)useSubclassOperation{
    
    LoadImageOperation *imageOperation = [LoadImageOperation new];
    imageOperation.loadDelegate = self; // 设置代理
    imageOperation.imgUrl = imgUrl;
    
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    [queue addOperation:imageOperation];
}

-(void)loadImageSource:(NSString *)url{
    
    NSData *imgData = [NSData dataWithContentsOfURL:[NSURL URLWithString:url]];
    UIImage *image = [UIImage imageWithData:imgData];
    if (imgData!=nil) {
        [self performSelectorOnMainThread:@selector(refreshImageView1:) withObject:image waitUntilDone:YES]; // 在主线程中刷新图片
    }else{
        NSLog(@"there no image data");
    }
    
}

自定义NSOperation子类main主要代码实现，当你自定义NSOperation，实现main方法时，就已经在分线程中了。

- (void)main {

    if (self.isCancelled) return;
    
    NSURL *url = [NSURL URLWithString:self.imgUrl];
    NSData *imageData = [NSData dataWithContentsOfURL:url];
            
    if (self.loadDelegate!=nil&&[self.loadDelegate respondsToSelector:@selector(loadImageFinish:)]) {
        
        [(NSObject *)self.loadDelegate performSelectorOnMainThread:@selector(loadImageFinish:) withObject:image waitUntilDone:NO];
    }
}

3.GCD

GCD,它是苹果为多核的并行运算提出的解决方案，所以会自动合理地利用更多的CPU内核（比如双核、四核），最重要的是它会自动管理线程的生命周期（创建线程、调度任务、销毁线程），完全不需要我们管理，我们只需要告诉干什么就行。

GCD的基本常用使用方法。

//后台执行(通常意义的理解为开分线程)
-(void)globalQueue{
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        [self loadImageSource:imgUrl1];
    });
}
//UI线程（通常说的主线程）执行(只是为了测试,长时间的加载不能放在主线程)
-(void)mainQueue{
    dispatch_async(dispatch_get_main_queue(), ^{
        [self loadImageSource:imgUrl1];
    });
}

//一次性执行(常用来写单例，程序执行该代码部分只会被创建一次)
-(void)dispatchOnce{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        [self loadImageSource:imgUrl1];
    });
}

//并发地执行循环迭代，该方法根据程序运行，不指定在主线程或分线程中
-(void)dispatchApply{
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    size_t count = 10;
    dispatch_apply(count, queue, ^(size_t i) {
        NSLog(@"是否为主线程 =====%d",[NSThread isMainThread]);
        NSLog(@"循环执行第%li次",i);
        //[self loadImageSource:imgUrl1];
    });
}

//后台执行：加载两张图片
-(void)globalQueue2{
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        UIImage *image1 = [self loadImage:imgUrl1];
        UIImage *image2 = [self loadImage:imgUrl2];
        
        dispatch_async(dispatch_get_main_queue(), ^{
            self.imageview1.image = image1;
            self.imageView2.image = image2;
        });
    });
}

//并发线程组
/*
 dispatch_group_t监听这个调度组里面的线程，然后等调度组里面的线程都完成之后，才会掉用dispatch_group_notify 更新UI。
 让后台两个线程并行执行，然后等两个线程都结束后，再汇总执行结果。

 */

-(void)dispatchGroup{
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_async(queue, ^{
        
        dispatch_group_t group = dispatch_group_create();
        
        __block UIImage *image1 = nil;
        __block UIImage *image2 = nil;
        
        
        dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            image1 = [self loadImage:imgUrl1];

        });
        
        dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            image2 = [self loadImage:imgUrl2];

        });
        
        dispatch_group_notify(group, dispatch_get_main_queue(), ^{
            // 汇总结果
            self.imageview1.image = image1;
            self.imageView2.image = image2;
            
        });
    });
}


// 延迟执行
-(void)dispatchAfter{
    NSLog(@"Delay 2 seconds");
    double delayInSeconds = 2.0;
    dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);
    dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
        [self loadImageSource:imgUrl1];
    });
}

// 自定义dispatch_queue_t 处于分线程中
-(void)defineDispatch{

    dispatch_queue_t urls_queue = dispatch_queue_create("minggo.app.com", NULL);
    dispatch_async(urls_queue, ^{
        NSLog(@"---是否为主线程-%d",[NSThread isMainThread]);
        [self loadImageSource:imgUrl1];
    });
}

-(void)loadImageSource:(NSString *)url{
    
    NSData *imgData = [NSData dataWithContentsOfURL:[NSURL URLWithString:url]];
    UIImage *image = [UIImage imageWithData:imgData];
    if (imgData!=nil) {
        [self performSelectorOnMainThread:@selector(refreshImageView1:) withObject:image waitUntilDone:YES];
    }else{
        NSLog(@"there no image data");
    }
    
}

参考大神文章 — 谈iOS多线程(NSThread、NSOperation、GCD)编程