1.线程的状态:
线程的状态.png
2.GCD
//1.创建队列
/*
参数1: C语言字符串,是一个标签,用来区分队列
参数2: DISPATCH_QUEUE_CONCURRENT -> 并发队列
DISPATCH_QUEUE_SERIAL -> 串行队列
*/
//串行队列 串行队列只会开辟一个子线程
dispatch_queue_t queue = dispatch_queue_create("GCD", DISPATCH_QUEUE_SERIAL);
//并发队列 并发队列可以开辟多个子线程
dispatch_queue_t queue = dispatch_queue_create("GCD", DISPATCH_QUEUE_CONCURRENT);
//主队列 添加到主队列中的任务意味着任务都会在主线程中执行
dispatch_queue_t queue = dispatch_get_main_queue();
/*
参数1: 队列的优先级
DISPATCH_QUEUE_PRIORITY_HIGH
DISPATCH_QUEUE_PRIORITY_DEFAULT
DISPATCH_QUEUE_PRIORITY_LOW
DISPATCH_QUEUE_PRIORITY_BACKGROUND
优先级从高到低的排序
参数2: 队列的标签
*/
dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
//2.封装任务
/*
参数1: queue 把任务添加到这个队列中
参数2: block块 用于添加任务
*/
//异步函数
dispatch_async(queue, ^{
//在这里执行想要执行的任务,GCD会自动根据上下文代码判断是否需要开辟线程
});
//同步函数
dispatch_sync(queue, ^{
//同步函数不开线程,直接再主线程中执行任务
});
注意: 不能再主线程中再次滴啊用同步行数并且把任务添加到主队列,会导致线程死锁
//如果当前线程已经是主线程,再调用这调用这个函数来回到主线程的话,会出现崩溃
dispatch_sync (dispatch_get_main_queue(), ^{
NSLog(@"abc");
});
3.线程安全问题
在进行多线程开发的时候,经常会发生不同的线程在同一时间对同一个数据进行操作,那么这个时候我们需要对数据资源进行加锁,以保证数据源的安全:
假设我们有下面一种情况使用多线程对一个数字进行不断的减法
#pragma mark 线程安全
-(void)asyncMethod1 {
dispatch_queue_t q = dispatch_queue_create(0, DISPATCH_QUEUE_CONCURRENT);
dispatch_async(q , ^{
[self subMethod:@"线程1"];
});
dispatch_async(q, ^{
[self subMethod:@"线程2"];
});
dispatch_async(q, ^{
[self subMethod:@"线程3"];
});
//真实的情况中可能会是在不同的地方都用了异步并行的方式调用了同一个方法
}
/#pragma mark 执行减法操作
-(void)subMethod:(NSString *)stu{
while (1) {
if (self.numbers > 0) {
for (int i = 0; i< 100000; i++) {}
self.numbers -= 1;
NSLog(@"%@使用了减法后剩余:%d",stu,self.numbers);
}else{
NSLog(@"%@发现减数为0",stu);
break;
}
}
}
/*
当调用 asyncMethod1 方法时
控制台最后打印了如下数据:
->线程1使用了减法后剩余:0
->线程1发现减数为0
->线程2使用了减法后剩余:-1
->线程2发现减数为0
->线程3使用了减法后剩余:-2
->线程3发现减数为0
*/
我们明明已经对numbers进行判断,只有大于0的时候才进行减1操作,为什么还会出现负数呢?
因为当三条线程同时调用"-(void)subMethod:(NSString *)stu;"方法时;
发现那个时候的"numbers = 1" 所有都同时进行了 减 1 的操作;
如果此处是对数组进行取值的,就会出现崩溃
//可以通过 @synchronized(锁死的对象){} 进行
@synchronized ( self.models<这个地方只能传OC对象类型> ) {
//在线程所内对数据源进行增加或减少的操作
}
//改写后的减法操作
-(void)subMethod:(NSString *)stu{
while (1) {
@synchronized ( self) {
//在线程所内对数据源进行增加或减少的操作
if (self.numbers > 0) {
for (int i = 0; i< 100000; i++) {}
self.numbers -= 1;
NSLog(@"%@使用了减法后剩余:%d",stu,self.numbers);
}else{
NSLog(@"%@发现减数为0",stu);
break;
}
}
}
}
4.GCD线程栅栏问题
#pragma mark 栅栏函数
-(void)method2{
dispatch_queue_t q = dispatch_queue_create("栅栏函数", DISPATCH_QUEUE_CONCURRENT);
//注意,栅栏函数不能使用全局并发队列
// dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(q, ^{NSLog(@"执行任务一");});
dispatch_async(q, ^{ NSLog(@"执行任务二");});
dispatch_barrier_async(q, ^{ NSLog(@"执行栅栏任务");});
dispatch_async(q, ^{NSLog(@"执行任务三");});
}
/*上面的方法,在多线程任务重,会限制性任务一和二,(一/二的先后顺序由系统控制)
当任务一和任务二执行完成以后,系统会再执行任务栅栏函数后的任务;
*/
5.GCD快速遍历数组
NSArray *characters = @[@"a",@"b",@"c",@"d",@"e"];
//普通的遍历方式
for (NSString *C in characters) {
NSLog(@"%@--%@",C,[NSThread currentThread]);
}
//普通的遍历方式会在本来的线程中进行串行遍历
//GCD遍历方
dispatch_queue_t q = dispatch_queue_create("并发队列", DISPATCH_QUEUE_CONCURRENT);
/*
参数1:遍历的次数,数组的count属性
参数2:队列 <只能用并发队列,如果用主队列就会线程死锁,如果是串行队列,那就不会开多个子线程>
参数3:遍历的 index
*/
dispatch_apply(characters.count, q, ^(size_t i) {
NSString *c = characters[i];
NSLog(@"%@--%@",c,[NSThread currentThread]);
});
//使用GCD并发队列遍历,系统会开辟子线程对数组元素同时进行遍历,提升APP性能
5.GCD group 队列组
GCD队列组的可以用于监听队列组中任务是否执行完,执行完后再执行下一个操作
-(void)GCDgroupDemo{
//创建队列
dispatch_queue_t q = dispatch_queue_create("group", DISPATCH_QUEUE_CONCURRENT);
//创建队列组
dispatch_group_t g = dispatch_group_create();
dispatch_group_async(g, q, ^{
for (double i = 0; i<=1.0; i+=0.00002) {
dispatch_sync(dispatch_get_main_queue(), ^{
self.p1.progress = i;
});
}
});
//往队列组里面添加队列和任务
dispatch_group_async(g, q, ^{
for (double i = 0; i<=1.0; i+=0.00001) {
dispatch_sync(dispatch_get_main_queue(), ^{
self.p2.progress = i;
});
}
});
//监听队列执行完成情况
dispatch_group_notify(g, q, ^{
NSLog(@"%@",[NSThread currentThread]);
for (double i = 0; i<=1.0; i+=0.00002) {
dispatch_sync(dispatch_get_main_queue(), ^{
self.p3.progress = i;
});
}
});
NSOperation
1.NSOperation的基本概念
NSOperation 是苹果封装的一个对象类型的多线程方式;
NSOperation不需要用户控制什么时候开线程执行任务
NSOperation可以控制同一时间内执行的任务数量
2.NSOperationQueue的基本使用
使用NSOperation 和 NSOperationqueue 实现多线程的步骤
1.将需要执行的任务封装到NSOperation中
2.将NSOperation对象封添加NSOperationqueue中
3.系统自动将NSOperationqueue中的NSOperation取出来
4.将NSOperation中封装的任务放在线程中执行
NSOperation的子类配合NSOperationQueue使用:
//1. NSInvocationOperation
NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:weakself selector:@selector(operationDemoMethod) object:nil];
NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:weakself selector:@selector(operationDemoMethod) object:nil];
NSInvocationOperation *op3 = [[NSInvocationOperation alloc] initWithTarget:weakself selector:@selector(operationDemoMethod) object:nil];
//2. NSBlockOperation
__weak typeof(self) weakself = self;
NSBlockOperation *op4 = [NSBlockOperation blockOperationWithBlock:^{[weakself operationDemoMethod]}];
NSBlockOperation *op5 = [NSBlockOperation blockOperationWithBlock:^{[weakself operationDemoMethod]}];
NSBlockOperation *op6 = [NSBlockOperation blockOperationWithBlock:^{[weakself operationDemoMethod]}];
//NSOperationQueue
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:op1];
[queue addOperation:op2];
[queue addOperation:op3];
[queue addOperation:op4];
[queue addOperation:op5];
[queue addOperation:op6];
3. NSOperation的线程依赖 和 监听
//1.封装任务到NSOperation中
NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:weakself selector:@selector(operationDemoMethod) object:nil];
NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:weakself selector:@selector(operationDemoMethod) object:nil];
NSInvocationOperation *op3 = [[NSInvocationOperation alloc] initWithTarget:weakself selector:@selector(operationDemoMethod) object:nil];
//2.添加线程依赖 <依赖是可以跨队列的,即: 不处于同一个NSOperationQueue中的NSOperation是可以使用依赖操作的>
[op2 addDependency:op1];
[op3 addDependency:op2];
/*
添加完这样的线程依赖后,当系统调取NSOperationQueue中的
任务,就会按照依赖顺序先执行op1中的任务,op1的任务执行结
束以后,才会执行op2中的任务,同理,op3也依赖于op2
*/
//3.创建NSOperationQueue 并添加 NSOperation
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:op1];
[queue addOperation:op2];
[queue addOperation:op3];
//4.线程的监听
op2.completionBlock = ^{
//op2执行完成后,想要实现的操作可以直接再这里调用
//这个方法和线程的依赖是差不多的
};
注意:不能出现循环依赖
[op2 addDependency:op1];
[op1 addDependency:op2];
//这么写,程序不会崩溃,但是op1 & op2 都不会执行
3. NSOperationQueue的暂停/回复/取消/最大并发数
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
/*控制queue的同时并发线程数是:3;
这里不能等同于控制只开3条线程;
queue队列可以开辟超过3条线程,但是同一时间内只会并发执行3条
*/
queue.maxConcurrentOperationCount = 3;
//暂停队列
/*
这里假设一个场景:
我们往队列中添加了10个任务,
队列的最大并发数为:3个
当队列开始执行任务的时候,但是又没有执行完成的时候,想暂停
那么我们可以使用一下方法实现NSOperationQueue的暂停
*/
[queue setSuspended:YES];
//同理,我们想要恢复NSOperationQueue的时候,只需要设置NO
[queue setSuspended:NO];
//注意:当点击暂停的时候,已经开始执行的任务会执行完成
//NSOperationQueue的暂停原理是:停止调取queue中未开始执行的任务
//NSOperationQueue 取消任务
[queue cancelAllOperations];
//被取消的NSOperationQueue 是不可再恢复执行的,
4. NSOperationQueue 回到主线程操作
通常我们开辟子线程都是用来执行耗时操作获取数据的,一旦数据获取,我们需要刷新UI展示给用户看,这个时候需要回到主线程刷新UI
NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
//1.执行耗时操作获取数据
.....
//2.获得数据以后,回到主线程刷新UI
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
//在此处已经回到主线程,可以直接执行刷新UI的代码
}];
}];
多线程的几种情况已经总结完成
如果您巧合看到这篇文章,想要交流可以直接留言,若有不足之处也请留言之处,十分感激;
