iOS多线程编程之Grand Central Dispatch(GCD)

时间  2019-11-19
标签 ios 多线程 编程 grand central dispatch gcd 栏目 iOS 繁體版
原文   原文链接

介绍：

Grand Central Dispatch 简称（GCD）是苹果公司开发的技术，以优化的应用程序支持多核心处理器和其余的对称多处理系统的系统。这创建在任务并行执行的线程池模式的基础上的。它首次发布在Mac OS X 10.6 ，iOS 4及以上也可用。程序员

设计：

GCD的工做原理是：让程序平行排队的特定任务，根据可用的处理资源，安排他们在任何可用的处理器核心上执行任务。数据库

一个任务能够是一个函数(function)或者是一个block。 GCD的底层依然是用线程实现，不过这样可让程序员不用关注实现的细节。编程

GCD中的FIFO队列称为dispatch queue，它能够保证先进来的任务先获得执行
dispatch queue分为下面三种：网络

Serial      

又称为private dispatch queues，同时只执行一个任务。Serial queue一般用于同步访问特定的资源或数据。当你建立多个Serial queue时，虽然它们各自是同步执行的，但Serial queue与Serial queue之间是并发执行的。多线程

Concurrent

又称为global dispatch queue，能够并发地执行多个任务，可是执行完成的顺序是随机的。并发

Main dispatch queue

它是全局可用的serial queue，它是在应用程序主线程上执行任务的。app

咱们看看dispatch queue如何使用框架

一、经常使用的方法dispatch_async

为了不界面在处理耗时的操做时卡死，好比读取网络数据，IO,数据库读写等，咱们会在另一个线程中处理这些操做，而后通知主线程更新界面。异步

用GCD实现这个流程的操做比前面介绍的NSThread  NSOperation的方法都要简单。代码框架结构以下：async

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{  
    // 耗时的操做  
    dispatch_async(dispatch_get_main_queue(), ^{  
        // 更新界面  
    });  
});

如下载图片为例子，代码以下：

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{  
    NSURL * url = [NSURL URLWithString:@"http://avatar.csdn.net/2/C/D/1_totogo2010.jpg"];  
    NSData * data = [[NSData alloc]initWithContentsOfURL:url];  
    UIImage *image = [[UIImage alloc]initWithData:data];  
    if (data != nil) {  
        dispatch_async(dispatch_get_main_queue(), ^{  
            self.imageView.image = image;  
         });  
    }  
});

系统给每个应用程序提供了三个concurrent dispatch queues。这三个并发调度队列是全局的，它们只有优先级的不一样。由于是全局的，咱们不须要去建立。咱们只须要经过使用函数dispath_get_global_queue去获得队列，以下：

dispatch_queue_t globalQ = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

这里也用到了系统默认就有一个串行队列main_queue

dispatch_queue_t mainQ = dispatch_get_main_queue();

虽然dispatch queue是引用计数的对象，可是以上两个都是全局的队列，不用retain或release。

二、dispatch_group_async的使用

dispatch_group_async能够实现监听一组任务是否完成，完成后获得通知执行其余的操做。这个方法颇有用，好比你执行三个下载任务，当三个任务都下载完成后你才通知界面说完成的了。下面是一段例子代码：

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);  
dispatch_group_t group = dispatch_group_create();  
dispatch_group_async(group, queue, ^{  
    [NSThread sleepForTimeInterval:1];  
    NSLog(@"group1");  
});  
dispatch_group_async(group, queue, ^{  
    [NSThread sleepForTimeInterval:2];  
    NSLog(@"group2");  
});  
dispatch_group_async(group, queue, ^{  
    [NSThread sleepForTimeInterval:3];  
    NSLog(@"group3");  
});  
dispatch_group_notify(group, dispatch_get_main_queue(), ^{  
    NSLog(@"updateUi");  
});  
dispatch_release(group);

dispatch_group_async是异步的方法，运行后能够看到打印结果：

 

2012-09-25 16:04:16.737 gcdTest[43328:11303] group1
2012-09-25 16:04:17.738 gcdTest[43328:12a1b] group2
2012-09-25 16:04:18.738 gcdTest[43328:13003] group3
2012-09-25 16:04:18.739 gcdTest[43328:f803] updateUi

每一个一秒打印一个，当第三个任务执行后，upadteUi被打印。

 

三、dispatch_barrier_async的使用

dispatch_barrier_async是在前面的任务执行结束后它才执行，并且它后面的任务等它执行完成以后才会执行

例子代码以下：

dispatch_barrier_async是在前面的任务执行结束后它才执行，并且它后面的任务等它执行完成以后才会执行

例子代码以下：

dispatch_queue_t queue = dispatch_queue_create("gcdtest.rongfzh.yc", DISPATCH_QUEUE_CONCURRENT);  
dispatch_async(queue, ^{  
    [NSThread sleepForTimeInterval:2];  
    NSLog(@"dispatch_async1");  
});  
dispatch_async(queue, ^{  
    [NSThread sleepForTimeInterval:4];  
    NSLog(@"dispatch_async2");  
});  
dispatch_barrier_async(queue, ^{  
    NSLog(@"dispatch_barrier_async");  
    [NSThread sleepForTimeInterval:4];  
  
});  
dispatch_async(queue, ^{  
    [NSThread sleepForTimeInterval:1];  
    NSLog(@"dispatch_async3");  
});

打印结果：

 

2012-09-25 16:20:33.967 gcdTest[45547:11203] dispatch_async1

2012-09-25 16:20:35.967 gcdTest[45547:11303] dispatch_async2

2012-09-25 16:20:35.967 gcdTest[45547:11303] dispatch_barrier_async

2012-09-25 16:20:40.970 gcdTest[45547:11303] dispatch_async3

请注意执行的时间，能够看到执行的顺序如上所述。

四、dispatch_apply 

执行某个代码片断N次。
dispatch_apply(5, globalQ, ^(size_t index) {
    // 执行5次
});

iOS多线程编程之NSOperation和NSOperationQueue的使用 

五、Demo

/**
 *  串行队列 Serial Diapatch Queue
 */
+(void)GCD_Serial_Diapatch_Queue{
    /*!
     * 建立串行队列
     * 第一个参数:queue的标记 可为NULL
     * 第二个参数:DISPATCH_QUEUE_SERIAL
     * 加到队列中的任务 按顺序执行
     */
    dispatch_queue_t myQueue = dispatch_queue_create("com.leoo.GCD", DISPATCH_QUEUE_SERIAL);
    
    dispatch_async(myQueue, ^{
        NSLog(@"task 1");
    });
    
    dispatch_async(myQueue, ^{
        NSLog(@"task 2");
    });
    
    dispatch_async(myQueue, ^{
        NSLog(@"task 3");
    });
}

/**
 *  并行队列 Concurrent Diapatch Queue
 */
+ (void)GCD_Concurrent_Diapatch_Queue{
    /*!
     * 建立并行队列
     * 第二个参数:DISPATCH_QUEUE_CONCURRENT
     * 加到队列中的任务 并行执行 顺序未知
     */
    dispatch_queue_t myQueue = dispatch_queue_create("com.leoo.GCD", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(myQueue, ^{
        NSLog(@"task 1");
    });
    
    dispatch_async(myQueue, ^{
        NSLog(@"task 2");
    });
    
    dispatch_async(myQueue, ^{
        NSLog(@"task 3");
    });
}


/**
 *  系统的主线程 queue
 *  Main Dispatch Queue（serial queue）
 *  全部的任务会追加到主线程执行 一般是UI操做
 */
+ (void)GCD_Main_Dispatch_Queue{
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"task UI");
    });
}

/**
 *  Global Dispatch Queue(concurrent queue)
 *  具备四个优先级分别为High，Default，Low，Background
 *  根据优先级来异步调度线程执行
 */
+ (void)GCD_Global_Dispatch_Queue{
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"async task");
    });
}

/**
 *  改变两个队列的执行优先级
 */
+ (void)GCD_dispath_set_target_queue{
    dispatch_queue_t mySerialQueue = dispatch_queue_create("com.leoo.GCD", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t myGlobalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
    //设置优先级
    dispatch_set_target_queue(mySerialQueue, myGlobalQueue);
    
    dispatch_async(mySerialQueue, ^{
        
        NSLog(@"hello");
    });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        
        NSLog(@"world");
    });
}

/**
 *  定时执行
 */
+ (void)GCD_dispatch_after{
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"code to be executed after a specified delay");
    });
}

/**
 *  异步并行 任务组依赖
 *  task1 和 task2 执行结束后才执行 task3
 */
+ (void)GCD_dispatch_group{
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_queue_create("com.leoo.GCD", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_async(group, queue, ^{
        NSLog(@"task 1");
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"task 2");
    });
    
    dispatch_group_notify(group, queue, ^{
        NSLog(@"task 3");
    });
}

/**
 *  异步并行 重复执行
 *  第一个参数为重复的次数，第二个参数为追加对象的dispatch queue,第三个参数为追加的处理block
 *  等待追加的任务执行结束
 */
+ (void)GCD_dispatch_apply{
    dispatch_apply(6, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(size_t index) {
        NSLog(@"task count %zu",index);
    });
    
    NSLog(@"done");
}

/**
 *  线程锁操做
 */
+ (void)GCD_dispatch_barrier_async{
    dispatch_queue_t queue = dispatch_queue_create("com.leoo.GCD", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"A");
    });
    
    dispatch_async(queue, ^{
        NSLog(@"B");
    });
    
    dispatch_barrier_async(queue, ^{ //前面的任务执行结束后它才执行，并且它后面的任务等它执行完成以后才会执行
        NSLog(@"C");
    });
    
    dispatch_async(queue, ^{
        NSLog(@"D");
    });
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程