一.概念
1.进程
1.进程是一个具有一定独立功能的程序关于某次数据集合的一次运行活动，它是操作系统分配资源的基本单元.
2.进程是指在系统中正在运行的一个应用程序，就是一段程序的执行过程,我们可以简单理解为手机程序上的一个app.
3.进程只有一个。
2.线程
1.程序执行流的最小单元，线程是进程中的一个实体.2.一个进程要想执行任务,必须要有线程,至少有一条线程.其实应用程序启动的时候我们的系统就会默认帮我们的应用程序开启一条线程,这条线程也叫做'主线程',或者'UI线程'
3.进程和线程的关系
1.线程是进程的执行单元，进程的所有任务都在线程中执行！
2.线程是 CPU 调用的最小单位
3.进程是 CPU 分配资源和调度的单位
4.一个程序可以对应过个进程,一个进程中可有多个线程,但至少要有一条线程
5.同一个进程内的线程共享进程资源
4.同步
只能在当前线程按先后顺序依次执行，不开启新线程。
5.异步
可以在当前线程开启多个新线程执行，可不按顺序执行。
6.队列
装载线程任务的队形结构。
7.并发
线程执行可以同时一起进行执行。
8.串行
线程执行只能依次逐一先后有序的执行。
二.ios多线程对比
NSThread
每个NSThread对象对应一个线程，真正最原始的线程。1.优点：NSThread轻量级最低，相对简单。2.缺点：手动管理所有的线程活动，如生命周期、线程同步、睡眠等。
NSOperation
自带线程管理的抽象类。1.优点：自带线程周期管理，操作上可更注重自己逻辑。2.缺点：面向对象的抽象类，只能实现它或者使用它定义好的两个子类：NSInvocationOperation和NSBlockOperation。
GCD
Grand Central Dispatch (GCD)是Apple开发的一个多核编程的解决方法。
1.优点：最高效，避开并发陷阱。
2.缺点：基于C实现。
选择小结
1.简单而安全的选择NSOperation实现多线程即可。2.处理大量并发数据，又追求性能效率的选择GCD。3.NSThread本人选择基本上是在做些小测试上使用，当然也可以基于此造个轮子。
四.使用方法
1.NSThread
//动态创建线程
-(void)dynamicCreateThread{
NSThread*thread = [[NSThread alloc] initWithTarget:selfselector:@selector(loadImageSource:) object:imgUrl];
thread.threadPriority = 1;// 设置线程的优先级(0.0 - 1.0，1.0最高级)
[threadstart];
}
//静态创建线程
-(void)staticCreateThread{
[NSThread detachNewThreadSelector:@selector(loadImageSource:) toTarget:selfwithObject:imgUrl];
}
//隐式创建线程
-(void)implicitCreateThread{
[selfperformSelectorInBackground:@selector(loadImageSource:) withObject:imgUrl];
}
-(void)loadImageSource:(NSString*)url{
NSData *imgData = [NSData dataWithContentsOfURL:[NSURL URLWithString:url]];
UIImage*image = [UIImageimageWithData:imgData];
if(imgData!=nil) {
[self performSelectorOnMainThread:@selector(refreshImageView:) withObject:image waitUntilDone:YES];
}else{
NSLog(@"there no image data");
}
}
-(void)refreshImageView:(UIImage*)image{
[self.imageView setImage:image];
}
补充知识点
NSThread *current = [NSThread currentThread]; //获取当前线程
NSThread*main = [NSThreadmainThread]; //获取主线程
[NSThread sleepForTimeInterval:2]; //暂停等待线程，也就是我们通常所说的延迟执行2秒
//在指定线程上执行操作
[selfperformSelector:@selector(run) onThread:thread withObject:nilwaitUntilDone:YES];
//在主线程上执行操作
[selfperformSelectorOnMainThread:@selector(run) withObject:nilwaitUntilDone:YES];
//在当前线程执行操作
[selfperformSelector:@selector(run) withObject:nil];
2.NSOperation
主要的实现方式：结合NSOperation和NSOperationQueue实现多线程编程。
1.实例化NSOperation的子类，绑定执行的操作。2.创建NSOperationQueue队列，将NSOperation实例添加进来。3.系统会自动将NSOperationQueue队列中检测取出和执行NSOperation的操作
//使用子类NSInvocationOperation3.GCD
-(void)useInvocationOperation{
NSInvocationOperation*invocationOperation = [[NSInvocationOperation alloc] initWithTarget:selfselector:@selector(loadImageSource:) object:imgUrl];
//[invocationOperation start];//直接会在当前线程主线程执行
NSOperationQueue *queue = [[NSOperationQueue alloc]init];
[queue addOperation:invocationOperation];
}
//使用子类NSBlockOperation
-(void)useBlockOperation{
NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
[selfloadImageSource:imgUrl];
}];
NSBlockOperation *blockOperation1 = [NSBlockOperation blockOperationWithBlock:^{
// 代码操作1
}];
NSBlockOperation *blockOperation2 = [NSBlockOperation blockOperationWithBlock:^{
// 代码操作2
}];
NSBlockOperation *blockOperation3 = [NSBlockOperation blockOperationWithBlock:^{
// 代码操作3
}];
/*
// 添加操作之间的依赖关系，所谓“依赖”关系，就是等待前一个任务完成后，后一个任务才能启动
// 依赖关系可以跨线程队列实现
// 提示：在指定依赖关系时，注意不要循环依赖，否则不工作。
*/
[blockOperation1addDependency:blockOperation];
[blockOperation2addDependency:blockOperation1];
[blockOperation3addDependency:blockOperation2];
NSOperationQueue *queue = [[NSOperationQueue alloc]init];
[queueaddOperation:blockOperation];
[queueaddOperation:blockOperation1];
[queueaddOperation:blockOperation2];
[queueaddOperation:blockOperation3];
[queuesetMaxConcurrentOperationCount:2];// 控制同时最大并发的线程数量
}
//使用继承NSOperation
-(void)useSubclassOperation{
LoadImageOperation *imageOperation = [LoadImageOperation new];
imageOperation.loadDelegate =self;// 设置代理
imageOperation.imgUrl = imgUrl;
NSOperationQueue *queue = [[NSOperationQueue alloc]init];
[queue addOperation:imageOperation];
}
-(void)loadImageSource:(NSString*)url{
NSData *imgData = [NSData dataWithContentsOfURL:[NSURL URLWithString:url]];
UIImage*image = [UIImageimageWithData:imgData];
if(imgData!=nil) {
[self performSelectorOnMainThread:@selector(refreshImageView1:) withObject:image waitUntilDone:YES]; // 在主线程中刷新图片
}else{
NSLog(@"there no image data");
}
}
GCD,它是苹果为多核的并行运算提出的解决方案，所以会自动合理地利用更多的CPU内核（比如双核、四核），最重要的是它会自动管理线程的生命周期（创建线程、调度任务、销毁线程），完全不需要我们管理，我们只需要告诉干什么就行。
GCD的基本常用使用方法。
//后台执行(通常意义的理解为开分线程)
-(void)globalQueue{
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[selfloadImageSource:imgUrl1];
});
}
//UI线程（通常说的主线程）执行(只是为了测试,长时间的加载不能放在主线程)
-(void)mainQueue{
dispatch_async(dispatch_get_main_queue(), ^{
[selfloadImageSource:imgUrl1];
});
}
//一次性执行(常用来写单例，程序执行该代码部分只会被创建一次)
-(void)dispatchOnce{
staticdispatch_once_tonceToken;
dispatch_once(&onceToken, ^{
[selfloadImageSource:imgUrl1];
});
}
//并发地执行循环迭代，该方法根据程序运行，不指定在主线程或分线程中
-(void)dispatchApply{
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
size_tcount =10;
dispatch_apply(count, queue, ^(size_ti) {
NSLog(@"是否为主线程 =====%d",[NSThreadisMainThread]);
NSLog(@"循环执行第%li次",i);
//[self loadImageSource:imgUrl1];
});
}
//后台执行：加载两张图片
-(void)globalQueue2{
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
UIImage*image1 = [selfloadImage:imgUrl1];
UIImage*image2 = [selfloadImage:imgUrl2];
dispatch_async(dispatch_get_main_queue(), ^{
self.imageview1.image = image1;
self.imageView2.image = image2;
});
});
}
//并发线程组
/*
dispatch_group_t监听这个调度组里面的线程，然后等调度组里面的线程都完成之后，才会掉用dispatch_group_notify 更新UI。
让后台两个线程并行执行，然后等两个线程都结束后，再汇总执行结果。
*/
-(void)dispatchGroup{
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(queue, ^{
dispatch_group_t group = dispatch_group_create();
__blockUIImage*image1 =nil;
__blockUIImage*image2 =nil;
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
image1 = [selfloadImage:imgUrl1];
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
image2 = [selfloadImage:imgUrl2];
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 汇总结果
self.imageview1.image = image1;
self.imageView2.image = image2;
});
});
}
// 延迟执行
-(void)dispatchAfter{
NSLog(@"Delay 2 seconds");
doubledelayInSeconds =2.0;
dispatch_time_tpopTime =dispatch_time(DISPATCH_TIME_NOW, delayInSeconds *NSEC_PER_SEC);
dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
[selfloadImageSource:imgUrl1];
});
}
// 自定义dispatch_queue_t 处于分线程中
-(void)defineDispatch{
dispatch_queue_turls_queue =dispatch_queue_create("minggo.app.com",NULL);
dispatch_async(urls_queue, ^{
NSLog(@"---是否为主线程-%d",[NSThreadisMainThread]);
[selfloadImageSource:imgUrl1];
});
}
-(void)loadImageSource:(NSString*)url{
NSData *imgData = [NSData dataWithContentsOfURL:[NSURL URLWithString:url]];
UIImage*image = [UIImageimageWithData:imgData];
if(imgData!=nil) {
[self performSelectorOnMainThread:@selector(refreshImageView1:) withObject:image waitUntilDone:YES];
}else{
NSLog(@"there no image data");
}
}
//异步缓存图片完成执行操作
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view.
//异步缓存图片完成执行操作
[selftest];
}
- (void)test{
dispatch_group_t group = dispatch_group_create();
NSArray*imageArray = [selfgetImageUrl];
for(inti=0;i
//进入组
dispatch_group_enter(group);
[[SDWebImageManager sharedManager].imageDownloader downloadImageWithURL:[NSURL URLWithString:imageArray[i]] options:SDWebImageDownloaderLowPriority progress:^(NSInteger receivedSize, NSInteger expectedSize, NSURL * _Nullable targetURL) {
}completed:^(UIImage*_Nullableimage,NSData*_Nullabledata,NSError*_Nullableerror,BOOLfinished) {
NSLog(@"正在缓存第%d张",i+1);
//离开组
dispatch_group_leave(group);
}];
}
//通知缓存完成
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"缓存完成");
});
}
- (NSArray*)getImageUrl{
NSString *path = [[NSBundle mainBundle] pathForResource:@"imageUrl" ofType:@"plist"];
return [NSArray arrayWithContentsOfFile:path];
}
创建没有参数的代码块
@property(nonatomic,strong) dispatch_block_t block;
延时2s触发
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2*NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
});
------------实例1------------
//如根据若干个url异步加载多张图片，然后在都下载完成后合成一张整图
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_async(group, queue, ^{
});
dispatch_group_async(group, queue, ^{
});
dispatch_group_async(group, queue, ^{
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
});
------------实例2------------
//dispatch_barrier_async（栅栏函数）
/*
1.在它前面的任务执行结束后它才执行，它后面的任务要等它执行完成后才会开始执行。
2.避免数据竞争
*/
//创建并发队列
dispatch_queue_t queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
NSLog(@"任务1---%@",[NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"任务2---%@",[NSThread currentThread]);
});
dispatch_barrier_async(queue, ^{
NSLog(@"任务3---%@",[NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"任务4---%@",[NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"任务5---%@",[NSThread currentThread]);
});
------------实例3------------
NSLog(@"1");
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"2");
});
NSLog(@"3");
//结果输出1,主线程死锁(主线程和主队列相互等待)
附上Demo: https://github.com/githubze/SKThread1
网友评论