【iOS】多线程的使用

线程

保证主线程的正常运行,主线程主要显示和处理UI
当你处理时间较长的会阻塞主线程的操作的时候,要用到分线程来处理

比如

下载大的文件 (耗时)
数据量较大的数据库操作(耗时)
文件的读写(耗时)

iOS多线程编程技术有三种
1.NSThread
2.NSOperation
3.GCD(全称 Grand Central Dispatch)
这三种编程方式从上到下,抽象度层次是从低到高的,抽象度越高的使用越简单，也是Apple最推荐使用的

NSThread 使用

优点：NSThread 比其他两个轻量级
缺点：需要自己管理线程的生命周期，线程同步，线程同步对数据的加锁会有一定的系统开销

#import "ViewController.h"

@interface ViewController ()
@end

@implementation ViewController
-(void)viewDidLoad
{
  [super viewDidLoad];

  // 1.第一种方式（可控的 实例方法）
  NSThread * thread = [[NSThread alloc]initWithTarget:self selector:@selector(threadMethod) object:nil];
  [thread start]; //开始
 
  // 2.第二种方式
  [NSThread detachNewThreadWithBlock:^{
    NSLog(@"当前在%@线程",[NSThread currentThread]);
  }];
  [NSThread detachNewThreadSelector:@selector(threadMethod) toTarget:self withObject:nil];
 
  // 3.第三种方式 静态方法
  [self performSelectorInBackground:@selector(threadMethod) withObject:nil];
}

-(void)threadMethod
{
  @autoreleasepool // 自动释放池（目前版本不需要创建了）
  {
    // 判断 当前执行这些代码的线程是不是主线程；
    BOOL result = [NSThread isMainThread];
    NSLog(@"是否主线程:%d",result);
   
    // 让线程休眠10s
    [NSThread sleepForTimeInterval:10];
   
    /** 回到主线程
    * 当前线程为主线程的时候，waitUntilDone:YES参数无效
    * YES会阻塞住线程，直到调用方法完成
    * NO不会阻塞线程，会继续执行
    */
    [self performSelectorOnMainThread:@selector(onMainThread) withObject:nil waitUntilDone:NO];
  }
}

-(void)onMainThread
{
  NSLog(@"回到主线程");
}
@end

NSOperation 使用

NSOperation不需要自己创建线程，只需要关注在分线程中完成的代码，然后把NSOperation放到NSOperationQueue中即可，NSOperationQueue会把代码放到分线程中执行

NSOperation是个抽象类，不具备封装操作的能力，所以必须使用它的子类

NSInvocationOperation
NSBlockOperation
自定义的子类继承NSOperation，实现内部相应的方法

综上所述：优点就是不需要我们关心线程的管理和数据的同步等事情，我们只需要把精力放在自己需要执行的操作上

#import "ViewController.h"
#import "WYSOper.h"

@interface ViewController ()
@end

@implementation ViewController
-(void)viewDidLoad
{
  [super viewDidLoad];
 
  [self useOperationQueue];
}

#pragma mark - NSInvocationOperation
-(void)useInvocationOperation
{
  NSInvocationOperation * invOper = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(oper1) object:nil];
  [invOper start];
 
}
-(void)oper1
{
  NSLog(@"oper1: %@",[NSThread isMainThread]?@"主线程":@"分线程");
}

#pragma mark - NSBlockOperation
-(void)useBlockOperation
{
  /**
  * NSBlockOperation 添加的主任务是在主线程中执行的， 添加的其他额外任务是在分线程中执行的
  */
  NSBlockOperation * blockOper = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"BlockOper: %@",[NSThread isMainThread]?@"主线程":@"分线程");
  }];
 
  //在block操作中添加额外任务
  [blockOper addExecutionBlock:^{
    NSLog(@"BlockOperOther: %@",[NSThread isMainThread]?@"主线程":@"分线程");
  }];
 
  [blockOper start];
}

#pragma mark - NSOperationQueue
-(void)useOperationQueue
{
    //自定义的子类继承NSOperation
  WYSOper * operA = [[WYSOper alloc]init];
  operA.threadName = @"T1";
 
  WYSOper * operB = [[WYSOper alloc]init];
  operB.threadName = @"T2";
 
  WYSOper * operC = [[WYSOper alloc]init];
  operC.threadName = @"T3";
 
  //创建队列
  NSOperationQueue * operQueue = [[NSOperationQueue alloc]init];
 
  //设置队列中最大的线程并发数 （队列一次最多只能执行多少个任务）
  [operQueue setMaxConcurrentOperationCount:10];
 
  //添加操作之间的依赖关系 (任务A依赖于任务B，任务A必须等到任务B完成之后才能执行)
  //[operA addDependency:operB];
 
  //设置优先级
  operC.queuePriority = NSOperationQueuePriorityLow;
  operB.queuePriority = NSOperationQueuePriorityVeryHigh;
 
  //把操作对象放入到操作队列中
  [operQueue addOperation:operA];
  [operQueue addOperation:operB];
  [operQueue addOperation:operC];
 
  //取消队列中的任务
  //[operQueue cancelAllOperations];
 
  //暂停队列
  //[operQueue setSuspended:YES];
 
  //继续
  //[operQueue setSuspended:NO];
}
@end

自定义的WYSOper类（WYSOper.m）

#import "WYSOper.h"

@implementation WYSOper

//重写Operation的main方法
-(void)main
{
  NSLog(@"线程名称:%@ - 当前在:%@",self.threadName,[NSThread isMainThread]?@"主线程":@"分线程");
}
@end

GCD（Grand Central Dispatch）

GCD是苹果公司开发的多核编程技术，以优化的应用程序支持多核心处理器和其他的对称多处理系统的系统。这建立在任务并行执行的线程池模式的基础上的

GCD的工作原理

让程序平行排队的特定任务，根据可用的处理资源，安排他们在任何可用的处理器核心上执行任务
一个任务可以是一个函数或者是一个block。 GCD的底层依然是用线程实现，不过这样可以让程序员不用关注实现的细节

GCD的任务

disptach_sync 没有创建线程的欲望，就在当前线程执行
最主要的目的，阻塞并行队列任务的执行，只有当前的同步任务执行完毕后，后续的任务才能够执行
应用场景：用户登录！
dispatch_async 有创建线程的欲望，但是创建多少条线程，取决与队列的类型

GCD的队列

串行队列 类似于跑步，只有一条跑道，最多能够有两条
如果存在异步任务，就会在新线程中执行异步任务，而同步任务依旧在当前线程中执行
并行队列 类似与赛跑，具体跑道的数量，由系统决定

#pragma mark - 串行队列
-(void)useQueueSerial
{
  //创建一个串行队列
  //GCD 中有一个类似于operationQueue的队列 dispatch_queue_t
  dispatch_queue_t serialQueue = dispatch_queue_create("queue1", DISPATCH_QUEUE_SERIAL);
 
  //同步sync放入操作内容
  dispatch_sync(serialQueue, ^{
    NSLog(@"串行 - sync - 当前在%@",[NSThread isMainThread]?@"主线程":@"分线程");
  });
 
  //异步async放入操作内容
  dispatch_async(serialQueue, ^{
    NSLog(@"串行 - async - 当前在%@",[NSThread isMainThread]?@"主线程":@"分线程");
  });
 
  dispatch_suspend(serialQueue); //暂停
 
  dispatch_resume(serialQueue); //继续
 
  /**
  * 在串行队列中的任务,都是需要等待的,必须等到上个任务执行完毕之后,才能执行下个任务
  * 如果任务是同步放入到串行队列中的,任务在主线程中执行;异步放入的任务,在分线程中执行
  * 队列可以暂停
  */
}

#pragma mark - 并行队列
-(void)useQueueConcurrent
{
  //创建一个并行队列
  //dispatch_queue_t conQueue = dispatch_queue_create("queue2", DISPATCH_QUEUE_CONCURRENT);
 
  /**
  * 系统提供的有一个并行队列，可以直接使用
  * 1. 队列的优先级 HIGH > DEFAULT > LOW > BACKGROUD
  * 2. 系统预留的参数位 0
  */
  dispatch_queue_t conQueueSystem = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
 
  //同步sync放入操作内容
  dispatch_sync(conQueueSystem, ^{
    NSLog(@"并行 - sync - 当前在%@",[NSThread isMainThread]?@"主线程":@"分线程");
  });
 
  //异步async放入操作内容
  dispatch_async(conQueueSystem, ^{
    NSLog(@"并行 - async - 当前在%@",[NSThread isMainThread]?@"主线程":@"分线程");
  });
 
  /**
  * 在并行队列中如果同步放入任务,任务也需要等待,必须等到上一个任务结束之后才执行下个任务,在主线程中执行
  * 异步放入任务,任务是并发执行,在分线程中执行
  * 并行队列不可以暂停
  */
}

#pragma mark - 主线程队列
-(void)getMainQueue
{
  //获取到主线程队列
  dispatch_queue_t mainQueue = dispatch_get_main_queue();
 
  //往主线程队列中异步放入任务
  dispatch_async(mainQueue, ^{
    NSLog(@"主线程 - %@",[NSThread isMainThread]?@"主线程":@"分线程");
  });
}

2017.1.20更新

-(void)viewDidLoad
{
    [super viewDidLoad];
    
    [[self class] networkRequestThread];
}

//创建一个网络通信线程
+(NSThread *)networkRequestThread
{
    static NSThread * _networkRequestThread = nil;
    
    static dispatch_once_t oncePredicate;
    
    dispatch_once(&oncePredicate, ^{
        
        _networkRequestThread = [[NSThread alloc] initWithTarget:self selector:@selector(networkRequestThreadEntryPoint:) object:nil];
        
        [_networkRequestThread start];
    });
    
    return _networkRequestThread;
}

//线程处理
+(void)networkRequestThreadEntryPoint:(id)__unused object
{
    @autoreleasepool
    {
        [[NSThread currentThread] setName:@"线程名称"]; 
        
        NSRunLoop * runLoop = [NSRunLoop currentRunLoop]; //设置runloop
        
        [runLoop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];
        
        [runLoop run];
    }
}

线程锁

多个线程同时访问公共资源，并对公共资源进行修改，容易出现数据错乱的情况，为解决此问题，需要使用线程锁

#pragma mark - 线程锁
-(void)useThreadLock
{
  // 第一种方式
  NSLock * mLock = [[NSLock alloc]init];
 
  [mLock lock]; //加锁
 
  [mLock unlock]; //解锁
 
  // 第二种方式
  // 当程序运行到@synchronized(self),先要判断别的线程有没有在使用同步对象,如果正在使用,当前线程需要等待,一直等到别的线程把同步块执行完毕,释放同步对象之后,当前线程才能执行
  @synchronized (self)
  {
    //...
  }
}

注意：Timer不能在分线程中直接使用，需要手动开启RunLoop

个人微信公众号：iapp666666

GitHub：https://github.com/29745560

【iOS】多线程的使用

你可能感兴趣的:(【iOS】多线程的使用)