1.进程
系统中正在运行的应用程序
每个进程之间是相互独立的，运行在各自独有且受保护的内存中
2.线程
1.进程是不具备执行任务，要想执行任务，至少要有一个线程
2.一个进程的所有任务，都是要在线程中执行
3.线程中任务执行是串行
3.1.一个线程要执行多个任务，只能一个任务执行完再去执行下一个任务
3.2.也就是说，同一时间，一个线程只能执行一个任务
3.进程与线程的区别
线程是CPU调度的最小单位
进程是CPU分配资源和调度的单位
一个程序可以有多个进程，一个进程可以有多个线程，但至少要有一个线程
同一个进程中的线程共享进程资源
4.多线程
一个进程中可以开启多个线程，每个线程并发执行不同任务
进程 － 车间，线程－ 车间工人
5.多线程的原理
同一时间内，CPU只能调度一条线程
多线程并发执行，实际上是CPU快速的在多条线程间不断调度（切换）
CPU调度的时间足够快，感觉就像是多线程并发执行的假象
如果线程非常多，CPU会在N多线程之间来回切换，会被累死，开启线程会消耗资源（CPU、内存），通常开三到五条线程
6.多线程的优缺点
优点
1.1能适当提高程序的执行效率
1.2.能适当提高系统的资源利用率
缺点
2.1.创建线程是有开销的，开启线程越多，CPU在调度线程的开销就越大
2.2.开启大量线程会影响性能
2.3.程序设计更加复杂：线程之间的通信、多线程的数据共享
7.主线程－UI线程
程序启动，系统默认会开启一条线程－主线程，也成UI线程
显示、刷新UI
处理UI事件（1.点击事件 2.滚动事件 3.拖拽事件）
注意：
1.不要将耗时操作放在主线程中执行（耗时操作会卡住主线程，严重影响UI的流畅度，给用户一种“卡”的坏体验）
2.UI操作必须放在主线程中执行
8.子线程
相对于主线程来说，非主线程就是子线程
9.iOS中多线程的实现方案
10.多线程的安全隐患
1.当多线程访问同一块资源时容易引发数据错乱和数据安全问题
2.安全隐患解决
3.加互斥锁（同步锁）
互斥锁使用格式
@synchronized(锁对象) { // 需要锁定的代码 }
注意：锁定1份代码只用1把锁，用多把锁是无效的
互斥锁的优缺点
1.优点：能有效防止因多线程抢夺资源造成的数据安全问题
2.缺点：需要消耗大量的CPU资源
互斥锁的使用前提：多条线程抢夺同一块资源
相关专业术语：线程同步
线程同步的意思是：多条线程在同一条线上执行（按顺序地执行任务）
互斥锁，就是使用了线程同步技术
11.原子性与非原子性
原子性－atomic：为setting方法加锁（线程安全）默认就是atomic
非原子性－nonatomic：不为setting方法加锁（线程不安全）
原子属性与非原子属性选择
atomic：线程安全，需要消耗大量资源
nonatomic：线程不安全，不需要消耗大量资源，适合内存小的移动设备
iOS开发建议
都用nonatomic
尽量避免多线程抢夺同一块资源
加锁、抢夺资源问题尽量在服务区端解决，减轻移动端压力
12.线程间通信
12.1.在1个进程中，线程往往不是孤立存在的，多个线程之间需要经常进行通信
12.2线程间通信的体现
12.2.1个线程传递数据给另1个线程
12.2.2.在1个线程中执行完特定任务后，转到另1个线程继续执行任务
12.3.线程间通信的方法
12.3.1- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;
12.3.2- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait;
13.NSThread:
13.1.NSThread的创建方式
13.1.1.创建NSThread对象
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(show) object:nil];
// 开启线程
[thread start];
// 方法
- (void)show {
NSLog(@"show -- %@", [NSThread currentThread]);
}
13.1.2.detachNewThreadSelector: toTarget: withObject:方式
[NSThread detachNewThreadSelector:@selector(download) toTarget:self withObject:nil];
// 方法
- (void)show {
NSLog(@"show -- %@", [NSThread currentThread]);
}
13.1.3.performSelector
[self performSelectorOnMainThread:@selector(show) withObject:nil waitUntilDone:YES];
// 方法
- (void)show {
NSLog(@"show -- %@", [NSThread currentThread]);
}
13.1.4.自定义，继承自NSThread，重写main方法
14.NSThread其他用法
14.1.获取主线程 [NSThread mainThread];
14.2.获取当前线程[NSThread currentThread];
14.3.判断是否是主线程
NSLog(@"%@", [NSThread currentThread]);看number是否为1，若为1，则是主线程，不为1，则是子线程
类方法[NSThread isMainThread];
对象方法[thread isMainThread];
14.4.设置线程的名字
- (void)setName:(NSString *)name;
thread.name = @"GS";
- (NSString *)name;
14.5.线程的状态
14.5.1启动线程
- (void)start;
// 进入就绪状态 -> 运行状态。当线程任务执行完毕，自动进入死亡状态
14.6.阻塞（暂停）线程
+ (void)sleepUntilDate:(NSDate *)date;
+ (void)sleepForTimeInterval:(NSTimeInterval)ti;
// 进入阻塞状态
14.7.强制停止线程
+ (void)exit;
// 进入死亡状态
注意：一旦线程停止（死亡）了，就不能再次开启任务
15.GCD
15.1.全称-Grand Central Dispatch
15.2.GCD的优势
GCD是苹果公司为多核的并行运算提出的解决方案
GCD会自动利用更多的CPU内核（比如双核、四核）
GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码
15.3.任务与队列
任务：执行什么操作
队列：用来存放任务
GCD的使用就2个步骤
定制任务
确定想做的事情
将任务添加到队列中
GCD会自动将队列中的任务取出，放到对应的线程中执行
任务的取出遵循队列的FIFO原则：先进先出，后进后出
15.4执行任务
GCD中有2个用来执行任务的常用函数
用同步的方式执行任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
queue：队列
block：任务
用异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
同步和异步的区别
同步：只能在当前线程中执行任务，不具备开启新线程的能力
异步：可以在新的线程中执行任务，具备开启新线程的能力
15.5.队列的类型
并发队列（Concurrent Dispatch Queue）
可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
并发功能只有在异步（dispatch_async）函数下才有效
串行队列（Serial Dispatch Queue）
让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）
15.6.同步、异步、并发、串行
同步和异步主要影响：能不能开启新的线程
同步：只是在当前线程中执行任务，不具备开启新线程的能力
异步：可以在新的线程中执行任务，具备开启新线程的能力
并发和串行主要影响：任务的执行方式
并发：允许多个任务并发（同时）执行
串行：一个任务执行完毕后，再执行下一个任务
15.7.线程间通信
从子线程回到主线程
dispatch_async(
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行耗时的异步操作...
dispatch_async(dispatch_get_main_queue(), ^{
// 回到主线程，执行UI刷新操作
});
});
15.8.延时执行
iOS常见的延时执行
1.调用NSObject的方法
[self performSelector:@selector(run) withObject:nil afterDelay:2.0];
// 2秒后再调用self的run方法
2.使用GCD函数
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 2秒后执行这里的代码...
});
3. 使用NSTimer
[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(test) userInfo:nil repeats:NO];
15.9.GCD中还有个用来执行任务的函数：（栅栏函数）
dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);
在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行
注意：苹果官方明确说明这个queue不能是全局的并发队列，什么原因没有说明
15.10.一次性代码（特点：整个程序只执行一次，线程安全）
使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
});
15.11.快速迭代
使用dispatch_apply函数能进行快速迭代遍历
dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index){
// 执行10次代码，index顺序不确定
});
15.12.队列组
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group,
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行1个耗时的异步操作
});
dispatch_group_async(group,
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行1个耗时的异步操作
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的异步操作都执行完毕后，回到主线程...
});
15.13.单例模式
单例模式的作用
可以保证在程序运行过程，一个类只有一个实例，而且该实例易于供外界访问
从而方便地控制了实例个数，并节约系统资源
单例模式的使用场合
在整个应用程序中，共享一份资源（这份资源只需要创建初始化1次）
ARC中，单例模式的实现
在.m中保留一个全局的static的实例
static id _instance;
重写allocWithZone:方法，在这里创建唯一的实例（注意线程安全）
+ (instancetype)allocWithZone:(struct _NSZone *)zone {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
_instance = [super allocWithZone:zone];
});
return _instance;
}
提供1个类方法让外界访问唯一的实例
+ (instancetype)sharedInstance {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
_instance = [[self alloc] init];
});
return _instance;
}
实现copyWithZone:方法
- (id)copyWithZone:(struct _NSZone *)zone {
return _instance;
}
16.NSOperation
16.1.简介
NSOperation的作用
配合使用NSOperation和NSOperationQueue也能实现多线程编程
NSOperation和NSOperationQueue实现多线程的具体步骤
1.先将需要执行的操作封装到一个NSOperation对象中
2.然后将NSOperation对象添加到NSOperationQueue中
3.系统会自动将NSOperationQueue中的NSOperation取出来
4.将取出的NSOperation封装的操作放到一条新线程中执行
16.2.NSOperation的子类
NSOperation是个抽象类，并不具备封装操作的能力，必须使用它的子类
使用NSOperation子类的方式有3种
1.NSInvocationOperation
2.NSBlockOperation
3.自定义子类继承NSOperation，实现内部相应的方法
16.3.NSInvocationOperation
1.创建NSInvocationOperation对象
- (id)initWithTarget:(id)target selector:(SEL)sel object:(id)arg;
2.调用start方法开始执行操作
- (void)start;
一旦执行操作，就会调用target的sel方法
注意
默认情况下，调用了start方法后并不会开一条新线程去执行操作，而是在当前线程同步执行操作
只有将NSOperation放到一个NSOperationQueue中，才会异步执行操作
16.4.NSBlockOperation
1.创建NSBlockOperation对象
+ (id)blockOperationWithBlock:(void (^)(void))block;
2.通过addExecutionBlock:方法添加更多的操作
- (void)addExecutionBlock:(void (^)(void))block;
注意：只要NSBlockOperation封装的操作数 > 1，就会异步执行操作
16.5.NSOperationQueue
NSOperationQueue的作用
NSOperation可以调用start方法来执行任务，但默认是同步执行的
如果将NSOperation添加到NSOperationQueue（操作队列）中，系统会自动异步执行NSOperation中的操作
添加操作到NSOperationQueue中
- (void)addOperation:(NSOperation *)op;
- (void)addOperationWithBlock:(void (^)(void))block;
16.6.最大并发数
什么是并发数
同时执行的任务数
比如，同时开3个线程执行3个任务，并发数就是3
最大并发数的相关方法
- (NSInteger)maxConcurrentOperationCount;
- (void)setMaxConcurrentOperationCount:(NSInteger)cnt;
16.7.队列的取消、暂停、恢复
取消队列的所有操作
- (void)cancelAllOperations;
提示：也可以调用NSOperation的- (void)cancel方法取消单个操作
暂停和恢复队列
- (void)setSuspended:(BOOL)b; // YES代表暂停队列，NO代表恢复队列
- (BOOL)isSuspended;
16.8.操作依赖
NSOperation之间可以设置依赖来保证执行顺序
比如一定要让操作A执行完后，才能执行操作B，可以这么写
[operationB addDependency:operationA]; // 操作B依赖于操作A
可以在不同queue的NSOperation之间创建依赖关系
注意：不能相互依赖
比如A依赖B，B依赖A
16.9.操作的监听
可以监听一个操作的执行完毕
- (void (^)(void))completionBlock;
- (void)setCompletionBlock:(void (^)(void))block;
16.10.自定义NSOperation
自定义NSOperation的步骤很简单
1.重写- (void)main方法，在里面实现想执行的任务
2.重写- (void)main方法的注意点
3.自己创建自动释放池（因为如果是异步操作，无法访问主线程的自动释放池）
4.经常通过- (BOOL)isCancelled方法检测操作是否被取消，对取消做出响应