OC底层探索(十九) 多线程

OC底层文章汇总

1.进程与线程

1.1 进程

• 进程是指在系统中正在运行的一个应用程序
• 每个进程之间是独立的，每个进程均运行在其专用的且受保护的内存空间内
• 目前在iOS中，一个进程就是一个app。

1.2 线程

• 线程是进程的基本执行单元，一个进程的所有任务都在线程中执行.
• 进程要想执行任务，必须得有线程，进程至少要有一条线程
• 程序启动会默认开启一条线程，这条线程被称为主线程或 UI 线程

1.3 进程与线程的关系

• 地址空间:同一进程的线程共享本进程的地址空间，而进程之间则是独立的地址空间。
• 资源拥有:同一进程内的线程共享本进程的资源如内存、I/O、cpu等，但是进程之间的资源是独立的。

区别：

1: 一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进 程都死掉。所以多进程要比多线程健壮。

2: 进程切换时，消耗的资源大，效率高。所以涉及到频繁的切换时，使用线程要好于进 程。同样如果要求同时进行并且又要共享某些变量的并发操作，只能用线程不能用进程

3: 执行过程:每个独立的进程有一个程序运行的入口、顺序执行序列和程序入口。但是 线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

4: 线程是处理器调度的基本单位，但是进程不是。 5: 线程没有地址空间,线程包含在进程地址空间中

2 多线程

2.1 概念

在一个进程中开启多条线程，每条线程可以并行执行不同的任务。

• 多线程的原理
  • 同一时间，CPU只能处理一条线程，只有一条线程在工作
  • 多线程并发，其实是CPU快速的在多条线程之间切换
  • 如果多线程切换速度特别快，就造成了多线程并发执行的假象

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

• 多线程的优缺点
• 优点

• 能适当提高程序的执行效率
• 能适当提高资源的利用率(CPU，内存)
• 线程上的任务执行完成后，线程会自动销毁

• 缺点

• 开启线程需要占用一定的内存空间(默认情况下，每一个线程都占 512 KB)
• 如果开启大量的线程，会占用大量的内存空间，降低程序的性能
• 线程越多，CPU 在调用线程上的开销就越大
• 程序设计更加复杂，比线程间的通信、多线程的数据共享

2.2 多线程的方式

2.2.1多线程方案

2.2.2 线程的生命周期

• 新建：实例化线程对象

• 就绪：向线程对象发送start消息，线程对象被加入可调度线程池等待CPU调度。

• 运行：CPU负责调度可调度线程池中线程的执行。线程执行完成之前，状态可能会在就绪和运行之间来回切换。就绪和运行之间的状态变化由CPU负责，程序员不能干预。

• 阻塞：当满足某个预定条件时，可以使用休眠或锁，阻塞线程执行。sleepForTimeInterval（休眠指定时长），sleepUntilDate（休眠到指定日期），@synchronized(self)：（互斥锁）。

• 死亡：正常死亡，线程执行完毕。非正常死亡，当满足某个条件后，在线程内部中止执行/在主线程中止线程对象

  • 还有线程的exit和cancel
  • [NSThread exit]：一旦强行终止线程，后续的所有代码都不会被执行。
  • [thread cancel]取消：并不会直接取消线程，只是给线程对象添加 isCancelled 标记。

2.3 NSThread、GCD、NSOperation

2.3.1 NSThread

2.3.1.1 创建线程

• init方式，需要手动启动

/** 方法一，需要start */
NSThread *thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething1:) object:@"NSThread1"];
// 线程加入线程池等待CPU调度，时间很快，几乎是立刻执行
[thread1 start];

• detachNewThreadSelector创建好之后自动启动

/** 方法二，创建好之后自动启动 */
[NSThread detachNewThreadSelector:@selector(doSomething2:) toTarget:self withObject:@"NSThread2"];

• performSelectorInBackground创建好之后也是直接启动

/** 方法三，隐式创建，直接启动 */
[self performSelectorInBackground:@selector(doSomething3:) withObject:@"NSThread3"];

2.3.1.2 NSThread的类方法

• 返回当前线程

// 当前线程
[NSThread currentThread];
NSLog(@"%@",[NSThread currentThread]);

// 如果number=1，则表示在主线程，否则是子线程
打印结果：{
    
    number = 1, name = main}

• 阻塞休眠

//休眠多久
[NSThread sleepForTimeInterval:2];
//休眠到指定时间
[NSThread sleepUntilDate:[NSDate date]];

• 其他的方法

//退出线程
[NSThread exit];
//判断当前线程是否为主线程
[NSThread isMainThread];
//判断当前线程是否是多线程
[NSThread isMultiThreaded];
//主线程的对象
NSThread *mainThread = [NSThread mainThread];

• 其他属性

 //线程名
 thread.name;
//线程是否在执行
thread.isExecuting;
//线程是否被取消
thread.isCancelled;
//线程是否完成
thread.isFinished;
//是否是主线程
thread.isMainThread;
//线程的优先级，取值范围0.0到1.0，默认优先级0.5，1.0表示最高优先级，优先级高，CPU调度的频率高
 thread.threadPriority;

• 线程之间的通信

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

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

2.3.2 GCD

2.3.2.1 概念

GCD全称Grand Central Dispatch,纯C语言，提供了非常大的函数。

任务（block） ：任务就是将要在线程中执行的代码，将这段代码用block封装好，然后将这个任务添加到指定的执行方式（同步执行和异步执行），等待CPU从队列中取出任务放到对应的线程中执行。

同步（sync） ：一个接着一个，前一个没有执行完，后面不能执行，不开线程。

异步（async）：开启多个新线程，任务同一时间可以一起执行。异步是多线程的代名词

队列：装载线程任务的队形结构。(系统以先进先出的方式调度队列中的任务执行)。在GCD中有两种队列：串行队列和并发队列。

并发队列：线程可以同时一起进行执行。实际上是CPU在多条线程之间快速的切换。（并发功能只有在异步（dispatch_async）函数下才有效）

串行队列：线程只能依次有序的执行。

GCD总结：将任务(要在线程中执行的操作block)添加到队列(自己创建或使用全局并发队列)，并且指定执行任务的方式(异步dispatch_async，同步dispatch_sync)

2.3.2.2 GCD的创建

• 使用dispatch_queue_create来创建队列对象，传入两个参数，第一个参数表示队列的唯一标识符，可为空。第二个参数用来表示串行队列（DISPATCH_QUEUE_SERIAL）或并发队列（DISPATCH_QUEUE_CONCURRENT)。

// 串行队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 并发队列
dispatch_queue_t queue1 = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);

• 主队列：主队列负责在主线程上调度任务，如果在主线程上已经有任务正在执行，主队列会等到主线程空闲后再调度任务。通常是返回主线程更新UI的时候使用。dispatch_get_main_queue()

  dispatch_async(dispatch_get_global_queue(0, 0), ^{
    
    
      // 耗时操作放在这里
3
      dispatch_async(dispatch_get_main_queue(), ^{
    
    
          // 回到主线程进行UI操作
3
      });
  });

• 全局并发队列：全局并发队列是就是一个并发队列，是为了让我们更方便的使用多线程。dispatch_get_global_queue(0, 0)

//全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//全局并发队列的优先级
#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高优先级
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默认（中）优先级
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低优先级
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台优先级
//iOS8开始使用服务质量，现在获取全局并发队列时，可以直接传0
dispatch_get_global_queue(0, 0);

• 同步/异步任务创建方式

同步（sync）使用dispatch_sync来表示。

异步（async）使用dispatch_async。

任务就是将要在线程中执行的代码，将这段代码用block封装好。

    // 同步执行任务
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
    
    
        // 任务放在这个block里
        NSLog(@"我是同步执行的任务");

    });
    // 异步执行任务
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
    
    
        // 任务放在这个block里
        NSLog(@"我是异步执行的任务");

    });

2.3.2.3 GCD的方法

由于有多种队列（串行/并发/主队列）和两种执行方式（同步/异步），所以他们之间可以有多种组合方式。

• 串行同步 DISPATCH_QUEUE_SERIAL

执行完一个任务，再执行下一个任务。不开启新线程。

/** 串行同步 */
- (void)syncSerial {
    
    

    // 串行队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);

    // 同步执行
    dispatch_sync(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"串行同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"串行同步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"串行同步3   %@",[NSThread currentThread]);
        }
    });
}

输出结果：

串行同步1   {
    
    number = 1, name = main}
串行同步1   {
    
    number = 1, name = main}
串行同步1   {
    
    number = 1, name = main}
串行同步2   {
    
    number = 1, name = main}
串行同步2   {
    
    number = 1, name = main}
串行同步2   {
    
    number = 1, name = main}
串行同步3   {
    
    number = 1, name = main}
串行同步3   {
    
    number = 1, name = main}
串行同步3   {
    
    number = 1, name = main}

• 串行异步 DISPATCH_QUEUE_SERIAL
  开启新线程，但因为任务是串行的，所以还是按顺序执行任务。

/** 串行异步 */
- (void)asyncSerial {
    
    

    // 串行队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);

    // 同步执行
    dispatch_async(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"串行异步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"串行异步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"串行异步3   %@",[NSThread currentThread]);
        }
    });
}

输入结果：

串行异步1   {
    
    number = 3, name = (null)}
串行异步1   {
    
    number = 3, name = (null)}
串行异步1   {
    
    number = 3, name = (null)}
串行异步2   {
    
    number = 3, name = (null)}
串行异步2   {
    
    number = 3, name = (null)}
串行异步2   {
    
    number = 3, name = (null)}
串行异步3   {
    
    number = 3, name = (null)}
串行异步3   {
    
    number = 3, name = (null)}
串行异步3   {
    
    number = 3, name = (null)}

• 并发同步 DISPATCH_QUEUE_CONCURRENT
  因为是同步的，所以执行完一个任务，再执行下一个任务。不会开启新线程。

/** 并发同步 */
- (void)syncConcurrent {
    
    
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);

    // 同步执行
    dispatch_sync(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"并发同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"并发同步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"并发同步3   %@",[NSThread currentThread]);
        }
    });
}

输入结果：

并发同步1   {
    
    number = 1, name = main}
并发同步1   {
    
    number = 1, name = main}
并发同步1   {
    
    number = 1, name = main}
并发同步2   {
    
    number = 1, name = main}
并发同步2   {
    
    number = 1, name = main}
并发同步2   {
    
    number = 1, name = main}
并发同步3   {
    
    number = 1, name = main}
并发同步3   {
    
    number = 1, name = main}
并发同步3   {
    
    number = 1, name = main}

• 并发异步DISPATCH_QUEUE_CONCURRENT
  任务交替执行，开启多线程。

/** 并发异步 */
- (void)asyncConcurrent {
    
    

    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);

    // 同步执行
    dispatch_async(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"并发异步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"并发异步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"并发异步3   %@",[NSThread currentThread]);
        }
    });
}

输入结果：

并发异步1   {
    
    number = 3, name = (null)}
并发异步2   {
    
    number = 4, name = (null)}
并发异步3   {
    
    number = 5, name = (null)}
并发异步1   {
    
    number = 3, name = (null)}
并发异步2   {
    
    number = 4, name = (null)}
并发异步3   {
    
    number = 5, name = (null)}
并发异步1   {
    
    number = 3, name = (null)}
并发异步2   {
    
    number = 4, name = (null)}
并发异步3   {
    
    number = 5, name = (null)}

• 主队列同步dispatch_get_main_queue dispatch_async

如果在主线程中运用这种方式，则会发生死锁，程序崩溃。

/** 主队列同步 */
- (void)syncMain {
    
    


    // 主队列
    dispatch_queue_t queue = dispatch_get_main_queue();

    dispatch_async(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"主队列同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"主队列同步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"主队列同步3   %@",[NSThread currentThread]);
        }
    });
}

• 主队列异步 dispatch_get_main_queue dispatch_sync

在主线程中任务按顺序执行。

/** 主队列异步 */
- (void)asyncMain {
    
    

    // 主队列
    dispatch_queue_t queue = dispatch_get_main_queue();

    dispatch_sync(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"主队列异步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"主队列异步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"主队列异步3   %@",[NSThread currentThread]);
        }
    });
}

输出结果：

主队列异步1   {
    
    number = 1, name = main}
主队列异步1   {
    
    number = 1, name = main}
主队列异步1   {
    
    number = 1, name = main}
主队列异步2   {
    
    number = 1, name = main}
主队列异步2   {
    
    number = 1, name = main}
主队列异步2   {
    
    number = 1, name = main}
主队列异步3   {
    
    number = 1, name = main}
主队列异步3   {
    
    number = 1, name = main}
主队列异步3   {
    
    number = 1, name = main}

• GCD线程之间通讯

开发中需要在主线程上进行UI的相关操作，通常会把一些耗时的操作放在其他线程，比如说图片文件下载等耗时操作。

当完成了耗时操作之后，需要回到主线程进行UI的处理，这里就用到了线程之间的通讯。

 - (IBAction)communicationBetweenThread:(id)sender {
    
    

    // 异步
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
    
    
        // 耗时操作放在这里，例如下载图片。（运用线程休眠两秒来模拟耗时操作）
        [NSThread sleepForTimeInterval:2];
        NSString *picURLStr = @"http://www.bangmangxuan.net/uploads/allimg/160320/74-160320130500.jpg";
        NSURL *picURL = [NSURL URLWithString:picURLStr];
        NSData *picData = [NSData dataWithContentsOfURL:picURL];
        UIImage *image = [UIImage imageWithData:picData];

        // 回到主线程处理UI
        dispatch_async(dispatch_get_main_queue(), ^{
    
    
            // 在主线程上添加图片
            self.imageView.image = image;
        });
    });
}

• GCD栅栏 dispatch_barrier_async
  当任务需要异步进行，但是这些任务需要分成两组来执行，第一组完成之后才能进行第二组的操作。这时候就用了到GCD的栅栏方法dispatch_barrier_async。

- (IBAction)barrierGCD:(id)sender {
    
    

    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);

    // 异步执行
    dispatch_async(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"栅栏：并发异步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"栅栏：并发异步2   %@",[NSThread currentThread]);
        }
    });

    dispatch_barrier_async(queue, ^{
    
    
        NSLog(@"------------barrier------------%@", [NSThread currentThread]);
        NSLog(@"******* 并发异步执行，但是34一定在12后面 *********");
    });

    dispatch_async(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"栅栏：并发异步3   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"栅栏：并发异步4   %@",[NSThread currentThread]);
        }
    });
}

上面代码的打印结果如下，开启了多条线程，所有任务都是并发异步进行。但是第一组完成之后，才会进行第二组的操作。

栅栏：并发异步1   {
    
    number = 3, name = (null)}
栅栏：并发异步2   {
    
    number = 6, name = (null)}
栅栏：并发异步1   {
    
    number = 3, name = (null)}
栅栏：并发异步2   {
    
    number = 6, name = (null)}
栅栏：并发异步1   {
    
    number = 3, name = (null)}
栅栏：并发异步2   {
    
    number = 6, name = (null)}
 ------------barrier------------{
    
    number = 6, name = (null)}
******* 并发异步执行，但是34一定在12后面 *********
栅栏：并发异步4   {
    
    number = 3, name = (null)}
栅栏：并发异步3   {
    
    number = 6, name = (null)}
栅栏：并发异步4   {
    
    number = 3, name = (null)}
栅栏：并发异步3   {
    
    number = 6, name = (null)}
栅栏：并发异步4   {
    
    number = 3, name = (null)}
栅栏：并发异步3   {
    
    number = 6, name = (null)}

• GCD延时执行 dispatch_after
  当需要等待一会再执行一段代码时，就可以用到这个方法了：dispatch_after。

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    
    
    // 5秒后异步执行
    NSLog(@"我已经等待了5秒！");
});
GCD实现代码只执行一次
使用dispatch_once能保证某段代码在程序运行过程中只被执行1次。可以用来设计单例。
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    
    
    NSLog(@"程序运行过程中我只执行了一次！");
});

• GCD快速迭代 dispatch_apply
  GCD有一个快速迭代的方法dispatch_apply，dispatch_apply可以同时遍历多个数字。

- (IBAction)applyGCD:(id)sender {
    
    

    NSLog(@"

************** GCD快速迭代 ***************

");

    // 并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

    // dispatch_apply几乎同时遍历多个数字
    dispatch_apply(7, queue, ^(size_t index) {
    
    
        NSLog(@"dispatch_apply：%zd======%@",index, [NSThread currentThread]);
    });
}

输出结果：

dispatch_apply：0======{
    
    number = 1, name = main}
dispatch_apply：1======{
    
    number = 1, name = main}
dispatch_apply：2======{
    
    number = 1, name = main}
dispatch_apply：3======{
    
    number = 1, name = main}
dispatch_apply：4======{
    
    number = 1, name = main}
dispatch_apply：5======{
    
    number = 1, name = main}
dispatch_apply：6======{
    
    number = 1, name = main}

• GCD队列组dispatch_group_async
  异步执行几个耗时操作，当这几个操作都完成之后再回到主线程进行操作，就可以用到队列组了。

队列组有下面几个特点：

• 所有的任务会并发的执行(不按序)。
• 所有的异步函数都添加到队列中，然后再纳入队列组的监听范围。
• 使用dispatch_group_notify函数，来监听上面的任务是否完成，如果完成, 就会调用这个方法。

队列组示例代码：

	 //创建一个队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //创建一个队列组
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_async(group, queue, ^{
    
    
        NSLog(@"download image1 start");
        //下载图片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];
        self.image1 =[UIImage imageWithData:data];
        NSLog(@"download image1 end");
    });
    
    dispatch_group_async(group, queue, ^{
    
    
        NSLog(@"download image2 start");
        //下载图片2
        NSURL *url = [NSURL URLWithString:@"http://pic38.nipic.com/20140228/5571398_215900721128_2.jpg"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        self.image2 =[UIImage imageWithData:data];
        NSLog(@"download image2 end");
    });
    
    //当这个队列组的所有队列全部完成，就会收到这个消息
    dispatch_group_notify(group, queue, ^{
    
    
        NSLog(@"download all images");
        //合成新图片
        UIGraphicsBeginImageContext(CGSizeMake(100, 100));
        [self.image1 drawInRect:CGRectMake(0, 0, 50, 100)];
        [self.image2 drawInRect:CGRectMake(50, 0, 50, 100)];
        UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
        UIGraphicsEndImageContext();
        
        //在主线程显示
        dispatch_async(dispatch_get_main_queue(), ^{
    
    
            self.imageView.image = image;
        });
    });

打印结果:

队列组：有一个耗时操作完成！
队列组：有一个耗时操作完成！
队列组：前面的耗时操作都完成了，回到主线程进行相关操作

2.3.3 NSOperation

2.3.3.1 介绍

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

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

  • 然后将NSOperation对象添加到NSOperationQueue中

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

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

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

  • NSInvocationOperation

  • NSBlockOperation

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

2.3.3.2 NSInvocationOperation

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

• 默认情况下，调用了start方法后并不会开一条新线程去执行操作，而是在当前线程同步执行操作,只有NSOperation放到一个NSOperationQueue中，才会异步执行。

 - (void)testNSInvocationOperation {
    
    
    // 创建NSInvocationOperation
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperation) object:nil];
    // 开始执行操作
    [invocationOperation start];
}

 - (void)invocationOperation {
    
    
    NSLog(@"NSInvocationOperation包含的任务，没有加入队列========%@", [NSThread currentThread]);
}

2.3.3.3 NSBlockOperation

把任务放到NSBlockOperation的block中，然后start。(只要NSBlockOperation封装的操作数大于1，就会异步执行。)

 - (void)testNSBlockOperation {
    
    
    // 把任务放到block中
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
    
    
        NSLog(@"NSBlockOperation包含的任务，没有加入队列========%@", [NSThread currentThread]);
    }];

    [blockOperation start];
}

• 但是NSBlockOperation有一个方法addExecutionBlock:，通过这个方法可以让NSBlockOperation实现多线程。

- (void)testNSBlockOperationExecution {
    
    
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
    
    
        NSLog(@"NSBlockOperation运用addExecutionBlock主任务========%@", [NSThread currentThread]);
    }];

    [blockOperation addExecutionBlock:^{
    
    
        NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务1========%@", [NSThread currentThread]);
    }];
    [blockOperation addExecutionBlock:^{
    
    
        NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务2========%@", [NSThread currentThread]);
    }];
    [blockOperation addExecutionBlock:^{
    
    
        NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务3========%@", [NSThread currentThread]);
    }];
    [blockOperation start];
}

打印结果：

NSBlockOperation运用addExecutionBlock========{
    
    number = 1, name = main}
addExecutionBlock方法添加任务1========{
    
    number = 3, name = (null)}
addExecutionBlock方法添加任务3========{
    
    number = 5, name = (null)}
addExecutionBlock方法添加任务2========{
    
    number = 4, name = (null)}

2.3.3.4 NSOperationQueue

• NSOperationQueue的作用

  • NSOperation可以调用start方法来执行任务，默认是同步的
  • 如果将NSOperation添加到NSOperationQueue(操作队列)中，系统会自动异步执行NSOperation中的操作

• NSOperationQueue只有两种队列：主队列、其他队列。其他队列包含了串行和并发。

• 队列的创建

主队列

NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];

其他队列

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

• 添加任务到队列：addOperation、addOperationWithBlock

- (void)testOperationQueue {
    
    
    // 创建队列，默认并发
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 创建操作，NSInvocationOperation
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationAddOperation) object:nil];
    // 创建操作，NSBlockOperation
    //blockOperationWithBlock 添加任务
    NSBlockOperation *blockOperation = [NSBlockOperation 	blockOperationWithBlock:^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"addOperation把任务添加到队列======%@", [NSThread currentThread]);
        }
    }];

//addOperation 添加任务
    [queue addOperation:invocationOperation];
    [queue addOperation:blockOperation];
}


 - (void)invocationOperationAddOperation {
    
    
    NSLog(@"invocationOperation===aaddOperation把任务添加到队列====%@", [NSThread currentThread]);
}

• 运用最大并发数实现串行：NSOperationQueue

- (void)testMaxConcurrentOperationCount {
    
    
    // 创建队列，默认并发
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 最大并发数为1，串行
    queue.maxConcurrentOperationCount = 1;

    // 最大并发数为2，并发
//    queue.maxConcurrentOperationCount = 2;


    // 添加操作到队列
    [queue addOperationWithBlock:^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"addOperationWithBlock把任务添加到队列1======%@", [NSThread currentThread]);
        }
    }];
    // 添加操作到队列
    [queue addOperationWithBlock:^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"addOperationWithBlock把任务添加到队列2======%@", [NSThread currentThread]);
        }
    }];

    // 添加操作到队列
    [queue addOperationWithBlock:^{
    
    
        for (int i = 0; i < 3; i++) {
    
    
            NSLog(@"addOperationWithBlock把任务添加到队列3======%@", [NSThread currentThread]);
        }
    }];
}

运行结果如下，当最大并发数为1的时候，虽然开启了线程，但是任务是顺序执行的，所以实现了串行。

你可以尝试把上面的最大并发数变为2，会发现任务就变成了并发执行。

addOperationWithBlock把任务添加到队列1======{
    
    number = 3, name = (null)}
addOperationWithBlock把任务添加到队列1======{
    
    number = 3, name = (null)}
addOperationWithBlock把任务添加到队列1======{
    
    number = 3, name = (null)}
addOperationWithBlock把任务添加到队列2======{
    
    number = 3, name = (null)}
addOperationWithBlock把任务添加到队列2======{
    
    number = 3, name = (null)}
addOperationWithBlock把任务添加到队列2======{
    
    number = 3, name = (null)}
addOperationWithBlock把任务添加到队列3======{
    
    number = 3, name = (null)}
addOperationWithBlock把任务添加到队列3======{
    
    number = 3, name = (null)}
addOperationWithBlock把任务添加到队列3======{
    
    number = 3, name = (null)}

• 取消操作：cancelAllOperations、cancel

//取消所有操作
- (void)cancelAllOperations

//取消单个操作
 - (void)cancel

• 暂停或继续操作：setSuspended、.suspended
  • 当队列调用了队列挂起的方法（ self.queue.suspended =
    YES;或者[self.queue setSuspended:YES];），队列里的执行方法立即停止，但是有一点需要注意的是，当block操作中，队列挂起是不起作用的，它是无法停止的，必须操作执行结束后才会生效。

// 暂停队列
[self.queue setSuspended:YES];
或者
self.queue.suspended = YES;

• 判断队列是否暂停:isSuspended

 - (BOOL)isSuspended

• NSOperationQueue设置队列监听与依赖

NSOperation有一个非常好用的方法，就是操作依赖。可以从字面意思理解：某一个操作（operation2）依赖于另一个操作（operation1），只有当operation1执行完毕，才能执行operation2，这时，就是操作依赖大显身手的时候了。

 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(@"执行完成");
    }];

• NSOperationQueue队列间的数据通信
  先创建了一个普通队列，在普通队列里执行俩个操作，当子线程的图片都下载下来后，回归主线程将其显示在UI界面上。

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];