##iOS开发之多线程开发之GCD

三.GCD(经常使用)

GCD(Grand Central Dispatch):牛逼的中枢调度器.GCD是基于C由苹果公司为了多核的并行运算提出的解决方案,GCD完全由系统去管理,我们只需要写出需要执行的认为,GCD会负责创建线程和调度你的任务,系统直接提供线程的管理.

####1. GCD的基本使用

• 同步函数和异步函数的区别:

  • 同步函数在当前线程中执行任务,不具备开启新的线程的能力.
  • 异步函数具备开启新的线程的能力.(立刻执行任务)

• 并发队列和串行队列的区别:

  • 并发队列:可以让多个任务同时并发进行(自动开启多个线程同时执行任务).
  • 并发功能只有在异步函数(dispatch_async)中才有效.
  • GCD默认已经提供了一个全局的并发队列(dispatch_get_global_queue),可以无需手动创建
  • 串行队列:一个任务执行完毕后,再执行下一个任务.

• 同步函数 主队列

主线程阻塞

-(void)Mainsync{

    NSLog(@"syncMain ----- begin");
    // 获取主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    //把任务加到队列中
    dispatch_sync(queue, ^{
        
        NSLog(@"MainSync1 --- %@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        
        NSLog(@"MainSync2 --- %@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        
        NSLog(@"MainSync3 --- %@",[NSThread currentThread]);
    });
    
    NSLog(@"syncMain ----- end");
   
}

运行结果:

当在主线程中添加一个同步任务的时候,会引起主线程阻塞.同步队列的特点是任务会立刻执行,可是当前主线程中需要完成Mainsync这个任务,而完成Mainsync又需要该同步任务完成,而想完成该同步任务,又需要主线程执行完Mainsync,这就形成了完成A需要B的完成,而B的完成又需要A完成.这样就形成了阻塞.

• 异步函数 主队列

只能在主线程中执行任务,不能创建新的线程

 */
- (void)asyncMain
{
    NSLog(@"asyncMain ----- begin");
    
    // 1.获得主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    // 2.将任务加入队列
    dispatch_async(queue, ^{
    
        NSLog(@"asyncMain1-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"asyncMain2-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"asyncMain3-----%@", [NSThread currentThread]);
    });
    
    NSLog(@"asyncMain ----- end");
}

运行结果:

由运行结果可以看出来异步函数添加的任务不是立刻执行,这就和同步函数的不同,同步函数是任务一添加就立刻执行任务.

• 异步函数 串行队列

会开启新的线程.任务是串行的,执行完一个任务,执行下一个任务.

- (void)asyncSerial
{
    // 1.创建串行队列:
    dispatch_queue_t queue = dispatch_queue_create("队列名", DISPATCH_QUEUE_SERIAL);
    //默认的就是串行队列: DISPATCH_QUEUE_SERIAL
//  dispatch_queue_t queue = dispatch_queue_create("队列名", NULL);
    
    // 2.将任务加入队列
    dispatch_async(queue, ^{
        NSLog(@"asyncSerial 1-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"asyncSerial 2-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"asyncSerial 3-----%@", [NSThread currentThread]);
    });
}

结果:

有结果可以看出来异步函数可以创建新的线程

• 同步函数 串行队列

不会开启新的线程,在当前线程下任务一个一个的执行

- (void)syncSerial
{
    // 1.创建串行队列
    dispatch_queue_t queue = dispatch_queue_create("队列名", DISPATCH_QUEUE_SERIAL);
    
    // 2.将任务加入队列
    dispatch_sync(queue, ^{
        NSLog(@"1-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"2-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"3-----%@", [NSThread currentThread]);
    });
}

结果:

由结果可以看出来:同步函数不能开启新的线程,而是在当前的线程中执行任务,这里就是在主线程中,并没有创建一个新的进程.

• 异步函数 并行队列

可以同时开启多条线程

- (void)asyncConcurrent
{
    // 1.创建一个并发队列
//    dispatch_queue_t queue = dispatch_queue_create("队列名", DISPATCH_QUEUE_CONCURRENT);
    
    // 1.获得全局的并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    // 2.将任务加入队列
    dispatch_async(queue, ^{
        for (NSInteger i = 0; i<10; i++) {
            NSLog(@"1-----%@", [NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (NSInteger i = 0; i<10; i++) {
            NSLog(@"2-----%@", [NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (NSInteger i = 0; i<10; i++) {
            NSLog(@"3-----%@", [NSThread currentThread]);
        }
    });
    
    NSLog(@"asyncConcurrent--------end");
//    dispatch_release(queue);
}

• 同步函数 并行队列

不会开启新的线程,并发队列必须和异步函数同时使用,失去了并发的能力.

- (void)syncConcurrent
{
    // 1.获得全局的并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    // 2.将任务加入队列
    dispatch_sync(queue, ^{
        NSLog(@"1-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"2-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"3-----%@", [NSThread currentThread]);
    });
    
    NSLog(@"syncConcurrent--------end");
}

结果:

####2. 线程间的通讯

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 图片的网络路径
        NSURL *url = [NSURL URLWithString:@"http://img.pconline.com.cn/images/photoblog/9/9/8/1/9981681/200910/11/1255259355826.jpg"];
        
        // 加载图片
        NSData *data = [NSData dataWithContentsOfURL:url];
        
        // 生成图片
        UIImage *image = [UIImage imageWithData:data];
        
        // 回到主线程
        dispatch_async(dispatch_get_main_queue(), ^{
            self.imageView.image = image;
        });
    });

####3. GCD的其他函数

• dispatch_ group_ async : 队列组

解决需求:当前有任务1 任务2 任务3.任务3必须在任务1和任务2完成后进行,而任务1和任务2没有限制.

- (void)group
{
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    // 创建一个队列组
    dispatch_group_t group = dispatch_group_create();
  
    // 1.下载图片1(任务1)
    dispatch_group_async(group, queue, ^{
        // 图片的网络路径
        NSURL *url = [NSURL URLWithString:@"http://img.pconline.com.cn/images/photoblog/9/9/8/1/9981681/200910/11/1255259355826.jpg"];
        
        // 加载图片
        NSData *data = [NSData dataWithContentsOfURL:url];
        
        // 生成图片
        self.image1 = [UIImage imageWithData:data];
    });
    
    // 2.下载图片2(任务2)
    dispatch_group_async(group, queue, ^{
        // 图片的网络路径
        NSURL *url = [NSURL URLWithString:@"http://pic38.nipic.com/20140228/5571398_215900721128_2.jpg"];
        
        // 加载图片
        NSData *data = [NSData dataWithContentsOfURL:url];
        
        // 生成图片
        self.image2 = [UIImage imageWithData:data];
    });
    
    // 3.将图片1、图片2合成一张新的图片(任务3 :并需任务1和任务2完成才可以进行)
    dispatch_group_notify(group, queue, ^{
        // 开启新的图形上下文
        UIGraphicsBeginImageContext(CGSizeMake(100, 100));
        
        // 绘制图片
        [self.image1 drawInRect:CGRectMake(0, 0, 50, 100)];
        [self.image2 drawInRect:CGRectMake(50, 0, 50, 100)];
        
        // 取得上下文中的图片
        UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
        
        // 结束上下文
        UIGraphicsEndImageContext();
        
        // 回到主线程显示图片
        dispatch_async(dispatch_get_main_queue(), ^{
            // 4.将新图片显示出来 
            self.imageView.image = image;
        });
    });
}

• 快速迭代
• 传统的文件的剪切

/**
* 传统文件剪切
*/
- (void)moveFile
{
   NSString *from = @"/Users/xiaomage/Desktop/From";
   NSString *to = @"/Users/xiaomage/Desktop/To";

   NSFileManager *mgr = [NSFileManager defaultManager];
   NSArray *subpaths = [mgr subpathsAtPath:from];

   for (NSString *subpath in subpaths) {
       NSString *fromFullpath = [from stringByAppendingPathComponent:subpath];
       NSString *toFullpath = [to stringByAppendingPathComponent:subpath];
       dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
           // 剪切
           [mgr moveItemAtPath:fromFullpath toPath:toFullpath error:nil];
       });
   }
}

• GCD的快速迭代

/**
* 快速迭代
*/
- (void)apply
{
   dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
   NSString *from = @"/Users/xiaomage/Desktop/From";
   NSString *to = @"/Users/xiaomage/Desktop/To";
   
   NSFileManager *mgr = [NSFileManager defaultManager];
   NSArray *subpaths = [mgr subpathsAtPath:from];
   
   dispatch_apply(subpaths.count, queue, ^(size_t index) {
       NSString *subpath = subpaths[index];
       NSString *fromFullpath = [from stringByAppendingPathComponent:subpath];
       NSString *toFullpath = [to stringByAppendingPathComponent:subpath];
       // 剪切
       [mgr moveItemAtPath:fromFullpath toPath:toFullpath error:nil];
       
       NSLog(@"%@---%@", [NSThread currentThread], subpath);
   });
}

• dispatch_once:只执行一次

- (void)once
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"------run");
    });
}

• dispatch_barrier_async:栅栏

- (void)barrier
{
    dispatch_queue_t queue = dispatch_queue_create("队列名", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        NSLog(@"----1-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"----2-----%@", [NSThread currentThread]);
    });
    
    dispatch_barrier_async(queue, ^{
        NSLog(@"----barrier-----%@", [NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"----3-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"----4-----%@", [NSThread currentThread]);
    });
}

作用:分割任务,现在任务的执行顺序.用栅栏分割任务1,任务2和任务3,任务4,这样效果就是先执行任务1和任务2(任务1,任务2没有先后,系统决定),在执行栅栏,在执行任务3,任务4(任务3,任务4没有先后,系统决定).

---