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方式，需要手动启动


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

• 设计ADuC845低噪声信号采集版	• 边缘计算与 CDN 的区别
• JAVA——明码	• 《Oracle MySQL编程自学与面试指南》从入门到精
• 产品思考 - 免费移动宽带自带魔百和的烦恼	• 爬虫入门经典(十五) \| 邪恶想法之爬取百度妹子

• Esp8266天猫精灵_RGB灯_非点灯平台	• STM32F103 串口1和串口3对发数据配合蓝牙模块
• TMS570学习【1】了解什么是TMS570	• 新闻稿 \| Qt公司收购froglogic公司以巩固市场领
• [Java]SpringBoot2整合mqtt服务器EMQ实现消息订	• 苹果群控投屏同步操作原理及运用的平台APP分享

• Esp8266天猫精灵_RGB灯_非点灯平台	• STM32F103 串口1和串口3对发数据配合蓝牙模块
• TMS570学习【1】了解什么是TMS570	• 新闻稿 \| Qt公司收购froglogic公司以巩固市场领
• [Java]SpringBoot2整合mqtt服务器EMQ实现消息订	• 苹果群控投屏同步操作原理及运用的平台APP分享
• STM32查询式按键输入[直接用寄存器]	• Ubuntu系统 USB设备端口绑定
• 2021-04-14 第四次按键输入实验	• Flutter扫码功能完美实现

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

1.进程与线程

1.1 进程

1.2 线程

1.3 进程与线程的关系

2 多线程

2.1 概念

2.2 多线程的方式

2.2.1多线程方案

2.2.2 线程的生命周期

2.3 NSThread、GCD、NSOperation

2.3.1 NSThread

2.3.1.1 创建线程

2.3.1.2 NSThread的类方法

2.3.2 GCD

2.3.2.1 概念

2.3.2.2 GCD的创建

2.3.2.3 GCD的方法

2.3.3 NSOperation

2.3.3.1 介绍

2.3.3.2 NSInvocationOperation

2.3.3.3 NSBlockOperation

2.3.3.4 NSOperationQueue