GCD 线程安全同步

学习、记录与分享

GCD 与 NSThread比较

GCD会自动利用更多的CPU内核、会自动管理线程的生命周期（创建线程、调度线程、销毁线程）开发者只需用GCD函数创建任务，加入队列，GCD会根据CPU内核自动创建线程（创建多少，怎么创建不许要管）去完成任务。NSThread需要开发者自己创建线程去完成任务。

GCD核心

函数：异步和同步
任务：创建任务
队列：将任务加入队列（串行队列、并发队列）

队列

并发队列
- 队列里的任务会自动开启多个线程并发执行,但是需要异步函数的任务才有效
- 队列只是影响任务执行的方式,实际上并不能决定是否开启新的线程,仅仅是并发队列允许多个线程同时运行,而串行队列只能是一个一个任务在同一线程执行.
- 创建并发队列
```
//通过直接创建的方式创建,参数决定是否是并发队列
```

//DISPATCH_QUEUE_CONCURRENT代表并发队列
//DISPATCH_QUEUE_SERIAL或NULL代表串行队列
//标示符代表这个队列的一个标记
dispatch_queue_t qune = dispatch_queue_create("创建", DISPATCH_QUEUE_CONCURRENT);
//通过获取全局队列来获得一个并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//这两个参数,第一个是优先级一般用默认,第二个直接设为0 是一个保留标记,实际作用不大

* 串行队列
+ 队列里的任务会以串行的形式一个一个按顺序执行
+ 创建串行队列

//直接创建
//DISPATCH_QUEUE_SERIAL或NULL代表串行队列
dispatch_queue_t queue = dispatch_queue_create("标示符", DISPATCH_QUEUE_SERIAL);
//获得主队列,也是一种串行队列
dispatch_queue_t queue = dispatch_get_main_queue();


#####函数
* 同步函数:执行之后不立即返回，等待任务完成才返回，会阻塞当下线程

//queue代表你要放入的队列
dispatch_sync(queue, ^{
//在这里写要执行的代码
});
`


* 异步函数:执行之后立即返回，不会阻塞当下线程

//queue代表你要放入的队列
dispatch_async(queue, ^{
//在这里写要执行的代码
});


* 栅栏函数

//隔断函数,前面执行完才会执行这个函数,这个函数执行完才会执行其他后面的函数
dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);

####不同的队列与函数的组合会有不同的效果
* 并行队列+异步函数:创建新的线程,并行执行任务
* 并行队列+同步函数:没有新的线程,串行执行任务
* 串行队列+异步函数:创建新的线程,串行执行任务
* 串行队列+同步函数:没有新的线程,串行执行任务
* 主队列+异步函数:没有新的线程,串行执行任务
* 主队列+同步函数:没有新的线程,串行执行任务(主队列虽然也是串行队列)

####下面通过GCD实现单一资源线程安全的多读单写
#####一 信号量#####
简单来说就是控制访问资源的数量，比如系统有两个资源可以被利用，同时有三个线程要访问，只能允许两个线程访问，第三个应当等待资源被释放后再访问。

#####二 使用#####
* 创建信号量

dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
// 1 是信号量的初始值这里只允许一个线程访问

* 提高信号量

dispatch_semaphore_signal(semaphore)

* 等待降低信号量

dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
// 如果semaphore计数大于等于1.计数－1，返回，程序继续运行。如果计数为0，则等待。


测试

dispatch_queue_t qune = dispatch_queue_create("x", DISPATCH_QUEUE_CONCURRENT);
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
__block int i = 1 , n = 1;
for (int index = 0; index < 100; index++) {

    dispatch_async(qune, ^(){
        i++;
        NSLog(@"%d %d\n", index,i);
        
    });
    
}

/*
 只能单写
 */
for (int index = 0; index < 100; index++) {
    
    dispatch_async(qune, ^(){
        
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);//
        n++;
        NSLog(@"%d xx  %d\n", index,n);

// sleep(1);
dispatch_semaphore_signal(semaphore);

    });
    
}

打印LOG：
2016-09-12 14:32:11.849 Mansory[4745:108806] 0 2
2016-09-12 14:32:11.849 Mansory[4745:108807] 2 4
2016-09-12 14:32:11.849 Mansory[4745:108805] 1 3
2016-09-12 14:32:11.850 Mansory[4745:108887] 3 5
2016-09-12 14:32:11.850 Mansory[4745:108888] 4 6
2016-09-12 14:32:11.851 Mansory[4745:108807] 6 8
2016-09-12 14:32:11.851 Mansory[4745:108806] 5 7
2016-09-12 14:32:11.851 Mansory[4745:108805] 7 9
2016-09-12 14:32:11.851 Mansory[4745:108887] 8 10
2016-09-12 14:32:11.851 Mansory[4745:108888] 9 11
.
.
index 是乱序的 因为是异步的   i值是乱序的 因为资源竞争的问题导致

2016-09-12 14:32:11.863 Mansory[4745:108910] 0 xx  2
2016-09-12 14:32:11.863 Mansory[4745:108807] 99 101
2016-09-12 14:32:11.868 Mansory[4745:108807] 39 xx  3
2016-09-12 14:32:11.868 Mansory[4745:108807] 42 xx  4
2016-09-12 14:32:11.868 Mansory[4745:108807] 43 xx  5
2016-09-12 14:32:11.868 Mansory[4745:108807] 45 xx  6
2016-09-12 14:32:11.868 Mansory[4745:108807] 46 xx  7
2016-09-12 14:32:11.868 Mansory[4745:108807] 48 xx  8
2016-09-12 14:32:11.869 Mansory[4745:108927] 50 xx  9
2016-09-12 14:32:11.869 Mansory[4745:108927] 51 xx  10
2016-09-12 14:32:11.869 Mansory[4745:108927] 53 xx  11
2016-09-12 14:32:11.869 Mansory[4745:108927] 54 xx  12
2016-09-12 14:32:11.869 Mansory[4745:108927] 56 xx  13
2016-09-12 14:32:11.869 Mansory[4745:108927] 57 xx  14
2016-09-12 14:32:11.870 Mansory[4745:108927] 59 xx  15
2016-09-12 14:32:11.870 Mansory[4745:108927] 61 xx  16
.
.
index 是乱序的 是异步的 n值是递增的有序的 资源安全


#### dispatch_group_t 队列同步
* 手动管理group关联的block的运行状态

dispatch_group_t group = dispatch_group_create();
__weak typeof(self) this = self;

dispatch_group_enter(group);
[this productEvlute]; //网络请求

self.requestProductSucess = ^{
//请求成功回调
     dispatch_group_leave(group);
};

dispatch_group_enter(group);
[this estimateServive]; //网络请求耗时操作
 
 self.requestServiceSucess = ^{
 //请求成功
      dispatch_group_leave(group);
  };
}
.
.

dispatch_group_notify(group, dispatch_get_main_queue(), ^{
//任务都完成回调
[this checkIFAllCommitSucess];
});
/*
进入dispatch_group_enter和退出dispatch_group_leave次数必须匹配
*/

*

   ````
   dispatch_group_async(group, queue, ^{ 
       //任务1
   });  
   dispatch_group_async(group, queue, ^{ 
       //任务2
   }); 
   .
   .
   dispatch_group_notify (group, queue, ^{ 
       //任务都complete
   }); 

   ````

GCD 线程安全同步-信号量