iOS - 多线程问题小结

多线程的优缺点

优点:多线程能够适当提高程序的执行效率，适当提高资源利用率(CPU、内存利用率)。
缺点:每开启一条线程需要占用一定的内存空间，那么可想而知，如果开启大量的线程就会消耗大量的内存空间，从而降低程序的性能。

多线程的几种实现方案

第一种：NSThread

介绍：OC语言，使用的是面向对象，简单易用，可以直接操作线程对象，但是需要程序员自己管理线程的生命周期，偶尔使用。
创建线程的三种方式:

 // 1.开启后 会自动开启新的线程去执行testClick这个方法
 NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(testClick) object:nil];
 [thread start];

// 2.类方法 同样是开启新的线程去执行任务
[NSThread detachNewThreadSelector:@selector(testClick) toTarget:self withObject:nil];

// 3.第三种方式
[self performSelectorInBackground:@selector(testClick) withObject:nil];

打印当前线程:[NSThread currentThread]
打印主线程:[NSThread mainThread]

线程之间的通信：线程往往不是孤立存在的，多个线程之间经常需要进行通信线程之间通，一个线程传递数据给另一个线程, 在一个线程中执行完特定任务后，转到另一个线程执行任务

回到主线程的方式:

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

第二种:GCD

介绍：全称是Grand Gentral Dispatch,使用的是纯C语言，提供了大量强大的函数，经常使用。

GCD的优势:会自动利用更多的CPU内核，自动管理线程的生命周期(线程的创建、调度任务、销毁线程),我们只需要告诉GCD想要执行的任务即可。

GCD中的两个概念：任务、队列

GCD的使用步骤：

1.定制任务：确定想要执行的操作
2.将定制的任务添加到队列中，GCD会利用FIFO的原则自动将任务从队列里面取出放到对应的线程中去执行。

GCD中的同步和异步：

1.同步：表示只能在当前线程中执行任务，没有开启新线程的能力
2.异步：可以在新的线程中执行任务，具备开启新线程的能力，但是不一定会开启新的线程。

GCD中的两种队列：

1.并发队列：可以让多个任务并发执行，但是只在异步条件下才有效。
2.串行队列：任务一个接着一个执行。

GCD的主要使用:

1.将任务添加到一个串行队列里面去同步执行
/**
    DISPATCH_QUEUE_SERIAL和NULL:串行队列
    DISPATCH_QUEUE_CONCURRENT:并发队列
    dispatch_sync:同步执行
    dispatch_async:异步执行
 */
dispatch_queue_t queue = dispatch_queue_create("XXX.queue", NULL);
dispatch_sync(queue, ^{
    // 当前线程是主线程
     NSLog(@" -- %@",[NSThread currentThread]);
});

2. 把任务放到全局并发队列中去同步执行 

dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 当前线程是主线程
        NSLog(@" -- %@",[NSThread currentThread]);
    });

3.将任务添加到全局并发队列中去异步执行 是使用最多的
/**
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0):全局并发队列
*/
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 当前线程是子线程
        NSLog(@" -- %@",[NSThread currentThread]);
    });

4. 把任务放到主队列中去执行，在这里虽然是异步，但是并没有开启新的线程
dispatch_async(dispatch_get_main_queue(), ^{
      // 当前线程是主线程
      NSLog(@" -- %@",[NSThread currentThread]);
});

各种队列的执行效果：

candy1.png

GCD线程间的通信：

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
           // 执行比较耗时的操作。。。。

               dispatch_async(dispatch_get_main_queue(),^{
               // 回到主线程，刷新UI等操作

              });
        });

GCD其他经常使用的：
dispatch_after:延迟执行

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(4.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        
        NSLog(@"过4s后需要执行的任务");
    });

利用GCD实现一次性代码：

static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 整个项目只需要执行一次的代码
        NSLog(@"只需要执行一次的代码");
    });

dispatch_barrier:相当于是设置一个障碍，在barrier里面的任务必须要等前面的任务执行完毕过后才会执行，在barrier后面的任务要等barrier的任务执行完毕过后才会执行，但是队列不能是全局的并发队列。

dispatch_queue_t queue = dispatch_queue_create("XXX", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@" 1 ");
    });
    dispatch_async(queue, ^{
        NSLog(@" 2 ");
    });
    dispatch_barrier_async(queue, ^{
        NSLog(@" barrier ");
    });
    dispatch_async(queue, ^{
        NSLog(@" 3 ");
    });
    dispatch_async(queue, ^{
        NSLog(@" 4 ");
    });

dispatch_group:队列组，先创建队列组。
dispatch_group_notify：前面的都执行完毕了才会执行这个任务

// 打印结果一定是4在123的后面，但是123之间是无序的
 dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"1");
    });
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"2");
    });
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"3");
    });
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"4");
    });

第三种：NSOperation

1.配合NSOperation和NSOperationQueue也能实现多线程,NSOperation本身是一个抽象类，并不具备封装操作的能力，必须使用其子类：NSInvocationOperation NSBlockOperation 自定义子类继承NSOperation，实现内部相应的方法

2.NSOperation来实现多线程的具体步骤：

先将需要执行的操作封装到一个NSOperation对象中
将NSOperation对象添加到NSOperationQueue中
系统会自动将NSOperationQueue中的NSOperation对象取出来，将取出来的NSOperation封装的操作放到一条新线程中执行

3.NSBlockOperation

NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{                
 // block里面放需要执行的操作   
 }];
// 开启任务
[operation start];

// 再添加一个操作
[operation1 addExecutionBlock:^{     // block里面放需要执行的操作    }];

PS:任务数量大于1的时候，才会开启新的线程去执行，只有一个任务的时候就在主线程执行。

// 1.创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
          // block里面放需要执行的操作

    }];

// 2.添加操作到队列中（自动异步执行）：就会自动开启任务不用去调用操作的start方法。
[queue addOperation:operation1];

也可以写成：

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue  addOperationWithBlock:^{    
 // block里面放需要执行的操作任务

}];

NSOperation中可以设置并发数:queue.maxCurrentOperationCount = 3
添加依赖：[operationB addDependency:operationA],表示操作B要等操作A完成之后才执行，需要注意的是不能设置相互依赖。

4.自定义NSOperation对象
WWOperation *operation = [[WWOperation alloc] init];
需要执行的任务要放在WWOperation里面，去重写-(void)main介个方法。。任务放到这个方法里面
所以在以后的项目中，遇到任务的代码特别多的时候，就可以自定义一个operation操作。在外面创建 添加到队列就可以使用了。

5.用NSOperation来实现线程之间的通信：

NSOperationQueue *queue = [[NSOperationQueue alloc] init];[queue addOperationWithBlock:^{   
  // 1.执行耗时操作  
  [[NSOperationQueue mainQueue] addOperationWithBlock:^{            
   // 2.回到主线程，刷新UI等操作

        }];   
 }];

6.取消队列的所有操作：
取消任务：cancelAllOperations ，一旦取消就不能再继续
暂停操作：[queue setSuspended:YES]
恢复操作： [queue setSuspended:NO]