GCD (dispatch_group、dispatch_barrier、基于线程安全的多读单写)

1、Dispatch Group

在追加到Dispatch Queue中的多个任务处理完毕之后想执行结束处理，这种需求会经常出现。如果只是使用一个Serial Dispatch Queue（串行队列）时，只要将想执行的处理全部追加到该串行队列中并在最后追加结束处理即可，但是在使用Concurrent Queue 时，可能会同时使用多个Dispatch Queue时，源代码就会变得很复杂。

在这种情况下，就可以使用Dispatch Group。

dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_queue_create("com.gcd-group.www", DISPATCH_QUEUE_CONCURRENT);
     
    dispatch_group_async(group, queue, ^{
        for (int i = 0; i < 1000; i++) {
            if (i == 999) {
                NSLog(@"11111111");
            }
        }
         
    });
     
    dispatch_group_async(group, queue, ^{
        NSLog(@"22222222");
    });
     
    dispatch_group_async(group, queue, ^{
        NSLog(@"33333333");
    });
 dispatch_group_notify(group, queue, ^{
        NSLog(@"done");
    });

控制台的输出：done是最后输出的，其他三个都是随机输出的

因为向Concurrent Dispatch Queue 追加处理，多个线程并行执行，所以追加处理的执行顺序不定。执行顺序会发生变化，但是此执行结果的done一定是最后输出的。

无论向什么样的Dispatch Queue中追加处理，使用Dispatch Group都可以监视这些处理执行的结果。一旦检测到所有处理执行结束，就可以将结束的处理追加到Dispatch Queue中，这就是使用Dispatch Group的原因。

-----下面试一个使用Dispatch Group异步下载两张图片，然后合并成一张图片的medo（注意，我们总是应该在主线程中更新UI）：

#import "ViewController.h"

@interface ViewController (){
    NSData *_twoData;
    NSData *_oneData;
}
@property (nonatomic, strong) UILabel *textLabel;
@property (nonatomic, strong) UIImageView *oneImgView;
@property (nonatomic, strong) UIImageView *twoImgView;
@property (nonatomic, strong) UIImageView *compositeImg;//合成图片、

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    self.view.backgroundColor = [UIColor whiteColor];
     [self operation1];

    self.oneImgView = [[UIImageView alloc]initWithFrame:CGRectMake(20, 100,(self.view.frame.size.width-60)/2, 150)];
    [self.view addSubview:self.oneImgView];
    self.twoImgView = [[UIImageView alloc]initWithFrame:CGRectMake(40+(self.view.frame.size.width-60)/2, 100,(self.view.frame.size.width-60)/2, 150)];
    [self.view addSubview:self.oneImgView];
    [self.view addSubview:self.twoImgView];

}

- (void)operation1 {
    UILabel *textLabel = [[UILabel alloc] initWithFrame:CGRectMake(0, 64,self.view.frame.size.width, 30)];
    textLabel.text = @"正在下载图片";
    textLabel.textAlignment = NSTextAlignmentCenter;
    [self.view addSubview:textLabel];
    self.textLabel = textLabel;
    [self group];
    NSLog(@"在下载图片的时候，主线程貌似还可以干点什么");
}

- (void)group {
    UIImageView *imageView = [[UIImageView alloc] init];
    [self.view addSubview:imageView];
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_queue_create("cn.gcd-group.www", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_async(group, queue, ^{
        NSLog(@"正在下载第一张图片");
        _oneData = [NSData dataWithContentsOfURL:[NSURL URLWithString:@"http://upload-images.jianshu.io/upload_images/1749933-7dba2836c716ea95.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240"]];
        self.oneImgView.image = [UIImage imageWithData:_oneData];
        NSLog(@"第一张图片下载完毕");
    });

    dispatch_group_async(group, queue, ^{
        NSLog(@"正在下载第二张图片");
        _twoData = [NSData dataWithContentsOfURL:[NSURL URLWithString:@"http://images2015.cnblogs.com/blog/471463/201509/471463-20150912212457684-585830854.png"]];
        NSLog(@"第二张图片下载完毕");
        self.twoImgView.image = [UIImage imageWithData:_twoData];
    });

    dispatch_group_notify(group, queue, ^{
        UIGraphicsBeginImageContext(CGSizeMake(375, 300));
//        [self.oneImgView drawRect:CGRectMake(0, 0, 150, 400)];
        [self.oneImgView.image drawInRect:CGRectMake(0, 0, self.view.frame.size.width/2, 250)];
        [self.twoImgView.image drawInRect:CGRectMake(self.view.frame.size.width/2,0, self.view.frame.size.width/2, 250)];
        UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();
        UIGraphicsEndPDFContext();
        dispatch_async(dispatch_get_main_queue(), ^{
            UIImageView *imageView = [[UIImageView alloc] initWithImage:newImage];
            imageView.frame = CGRectMake(0, 400, self.view.frame.size.width, 300);
            [self.view addSubview:imageView];
            self.textLabel.text = @"图片合并完毕";
            NSLog(@"图片合并完毕");
            self.oneImgView.image = [UIImage imageWithData:_oneData];
            self.twoImgView.image = [UIImage imageWithData:_twoData];
        });

    });
}
@end

屏幕快照 2017-05-18 下午4.34.37.png

2、dispatch_barrier_async

在访问数据库或者文件的时候，我们可以使用Serial Dispatch Queue可避免数据竞争问题，代码如下所示：
先看看，如果我们在平常编码中，如果要保证某个属性可以线程安全的读写，如何写的：

#import 
@interface ZYPerson : NSObject
@property (nonatomic, copy) NSString *name;
@end
#import "ZYPerson.h"
-(void)setName:(NSString *)name {
   @synchronized(self) {
       _name = [name copy];
   }
}
-(NSString *)name {
   @synchronized(self) {
       return _name;
   }
}
@end

这是我在刚学iOS开发，刚涉及并发中的数据竞争时，书本上提到的一种解决方案。如果有多个线程要执行同一份代码，那么有时候可能会出现问题，这种情况下，通常要使用锁来实现某种同步机制。iOS提供了一种加锁的方式，就是采用内置的synchronization block，也就是上面代码所写的。
这种写法会根据给定的对象，自动创建一个锁，并等待块中的代码执行完毕。执行到这段代码结尾处，锁也就释放了。在上面的例子中，同步行为所针对的对象是self。这么写通常没错，但是@synchronized(self)会大大降低代码效率，甚至很多时候，还可以被人感觉到效率明显下降了，因为共用同一个锁的那些同步块，都必须按顺序执行。若在self对象上频繁加锁，那么程序可能就要等另一段与此无关的代码执行完毕，才可以继续执行当前代码，这样做是很没必要的。
@synchronized(self)会大大降低代码效率，因为所有的同步块（ @synchronized(self) ）都会彼此抢夺同一个锁。要是有多个属性这么写，每个属性的同步块（ @synchronized(self) ）都要等其他所有的同步块执行完毕之后才能执行，这并不是我们想要的结果，我们只想要每个属性各自独立的同步。
还有，不得不说，按上面这么做，虽然可以在一定程度上提供“线程安全”，但却无法保证访问该对象时是绝对线程安全的。事实上，上面的写法，就是atomic，也就是原子性属性xcode自动生成的代码，这种方法，在访问属性时，必定可以从中得到有效值，然而如果在一个线程上多次调用getter方法，每次得到的结果却未必相同，在两次读操作之间，其他线程可能会写入新的属性值。

其实使用GCD可以简单高效的代替同步块或者锁对象，可以使用，串行同步队列，将读操作以及写操作都安排在同一个队列里，即可保证数据同步，代码如下：

#import 
@interface ZYPerson : NSObject
@property (nonatomic, copy) NSString *name;
@end
#import "ZYPerson.h"
@interface ZYPerson ()
-(instancetype)init {
   if (self = [super init]) {
      _queue = dispatch_queue_create("com.person.syncQueue", DISPATCH_QUEUE_SERIAL);
   }
   return self;
}
-(void)setName:(NSString *)name {
   dispatch_sync(_queue, ^{
       _name = [name copy];
   });
}
-(NSString *)name {
   __block NSString *tempName;
   dispatch_sync(_queue, ^{
       tempName = _name;
   });
   return tempName;
}
@end

这样写的思路是：把写操作与读操作都安排在同一个同步串行队列里面执行，这样的话，所有针对属性的访问操作就都同步了。
这种方法的确已经足够好了，但还不是最优的，它只可以实现单读、单写。整体来看，我们最终要解决的问题是，在写的过程中不能被读，以免数据不对，但是读与读之间并没有任何的冲突！
多个getter方法（也就是读取）是可以并发执行的，而getter(读)与setter（写）方法是不能并发执行的，利用这个特点，还能写出更快的代码来，这次注意，不用串行队列，而改用并行队列：

-(instancetype)init {
   if (self = [super init]) {
      _concurrentQueue = dispatch_queue_create("com.person.syncQueue", DISPATCH_QUEUE_CONCURRENT);
   }
   return self;
}
-(void)setName:(NSString *)name {
   dispatch_barrier_async(_concurrentQueue, ^{
       _name = [name copy];
   });
}
-(NSString *)name {
   __block NSString *tempName;
   dispatch_sync(_concurrentQueue, ^{
       tempName = _name;
   });
   return tempName;
} @end

这样优化，测试一下性能，可以发现这种做法肯定比使用串行队列要快。
在这个代码中，我用了点新的东西，dispatch_barrier_async，可以翻译成栅栏（barrier），它可以往队列里面发送任务（块，也就是block），这个任务有栅栏（barrier）的作用。
在队列中，barrier块必须单独执行，不能与其他block并行。这只对并发队列有意义，并发队列如果发现接下来要执行的block是个barrier block，那么就一直要等到当前所有并发的block都执行完毕，才会单独执行这个barrier block代码块，等到这个barrier block执行完毕，再继续正常处理其他并发block。在上面的代码中，setter方法中使用了barrier block以后，对象的读取操作依然是可以并发执行的，但是写入操作就必须单独执行了。

（1）并行：就是队列里面的任务（代码块，block）不是一个个执行，而是并发执行，也就是可以同时执行的意思

（2）串行：队列里面的任务一个接着一个执行，要等前一个任务结束，下一个任务才可以执行

（3）异步：具有新开线程的能力

（4）同步：不具有新开线程的能力，只能在当前线程执行任务

（5）并行+异步：就是真正的并发，新开有有多个线程处理任务，任 务并发执行（不按顺序执行）

（6）串行+异步：新开一个线程，任务一个接一个执行，上一个任务处理完毕，下一个任务才可以被执行

（7）并行+同步：不新开线程，任务一个接一个执行

（8）串行+同步：不新开线程，任务一个接一个执行

并行+同步

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       dispatch_sync(dispatch_get_main_queue(), ^{
           NSLog(@"11  %@",[NSThread currentThread]);
       });
   });  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       dispatch_sync(dispatch_get_main_queue(), ^{
           NSLog(@"22  %@",[NSThread currentThread]);
       });
   });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       dispatch_sync(dispatch_get_main_queue(), ^{
           NSLog(@"33  %@",[NSThread currentThread]);
       });
   });
    
 dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       dispatch_sync(dispatch_get_main_queue(), ^{
           NSLog(@"44  %@",[NSThread currentThread]);
       });
   });
    
 dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       dispatch_sync(dispatch_get_main_queue(), ^{
           NSLog(@"55  %@",[NSThread currentThread]);
       });
   });

打印：在一个线程里面，任务一个接一个的执行。

并行+同步，并发调用：

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
   dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       NSLog(@"11  %@",[NSThread currentThread]);
   });
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
   dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       NSLog(@"22  %@",[NSThread currentThread]);
   });
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
   dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       NSLog(@"33  %@",[NSThread currentThread]);
   });
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
   dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       NSLog(@"44  %@",[NSThread currentThread]);
   });
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
   dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       NSLog(@"55  %@",[NSThread currentThread]);
   });
}); 

打印：新开了多个线程，任务并发执行。