[IOS 开发] GCD常用方法

1:dispatch_source_t

    //dispatch_source_t 默认是挂起的,需要dispatch_resume()
    //这个和子线程处理数据主线程更新界面的优点在于,当主线程比较空闲一起更新界面.效率更高
    dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_DATA_ADD, 0, 0, dispatch_get_main_queue());
    
    dispatch_source_set_event_handler(source, ^{
        NSLog(@"%ld",dispatch_source_get_data(source));
    });
    
    dispatch_resume(source);
    
    dispatch_apply(100, dispatch_get_global_queue(0, 0), ^(size_t index) {
        // do some work on data at index
        dispatch_source_merge_data(source, 1);
    });

2:GCD定时器

//    dispatch_suspend(dispatch_object_t object);  //暂停线程
//    dispatch_resume(dispatch_object_t object);   //恢复线程
//    dispatch_source_set_timer(dispatch_source_t source,   //timer
//                              dispatch_time_t start,      //dispatch_time(开始时间,延迟多少秒)
//                              uint64_t interval,          //间隔时间
//                              uint64_t leeway);           //可以误差时间
    
    __block int timeout = 30; //倒计时时间
    
    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0,  dispatch_get_main_queue());
    
    dispatch_source_set_timer(timer, dispatch_time(DISPATCH_TIME_NOW, 0ull*NSEC_PER_SEC), 1ull*NSEC_PER_SEC, 2ull*NSEC_PER_SEC);
    
    dispatch_source_set_event_handler(timer, ^{
        
        if(timeout == 0) //倒计时结束，关闭
        {
            NSLog(@"结束");
            dispatch_source_cancel(timer);        //没有dispatch_source_cancel()方法,timer不会执行
//          dispatch_suspend(timer);
        }
        else
        {
            NSLog(@" == %@, == %@",[NSString stringWithFormat:@"%.2d", timeout--],[NSDate new]);
        }
    });
    
    dispatch_source_set_cancel_handler(timer, ^{
        NSLog(@"cancel");
    });
    
    //启动
    dispatch_resume(timer);

3:group,GCD编组的功能

dispatch_group_t group = dispatch_group_create();dispatch_group_wait(group, DISPATCH_TIME_NOW);
    dispatch_group_async(group, dispatch_get_global_queue(0,0), ^{
        NSLog(@"============1");
    });
    dispatch_group_async(group, dispatch_get_global_queue(0,0), ^{
        sleep(10);
        NSLog(@"============2");
    });
    
    //保证dispatch_group_notify是最后输出
    dispatch_group_notify(group, dispatch_get_global_queue(0,0), ^{
        NSLog(@"============3");
    });
    
    dispatch_queue_t aDQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
    dispatch_group_t group1 = dispatch_group_create();
    
    dispatch_queue_t aDQueue2 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
    dispatch_group_t group2 = dispatch_group_create();
    
    // Add a task to the group
    dispatch_group_async(group1, aDQueue, ^{
        printf("task 1 \n");
    });
    dispatch_group_async(group1, aDQueue, ^{
        printf("task 2 \n");
    });
    dispatch_group_async(group1, aDQueue, ^{
        printf("task 3 \n");
    });
    dispatch_group_wait(group1, DISPATCH_TIME_FOREVER);
    printf("task 1 2 3 finished \n");
    
    
    dispatch_group_async(group2, aDQueue2, ^{
        printf("task2 1 \n");
    });
    dispatch_group_async(group2, aDQueue2, ^{
        printf("task2 2 \n");
    });
    dispatch_group_async(group2, aDQueue2, ^{
        printf("task2 3 \n");
    });
    dispatch_group_wait(group2, DISPATCH_TIME_FOREVER);
    printf("task2 1 2 3 finished \n");

4:用户自定义队列

    //队列之间的依赖关系
    //用户队列最主要的功能就是安排 线程之间的执行顺序.
    dispatch_queue_t targetQueue = dispatch_queue_create("test.target.queue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_queue_t queue1 = dispatch_queue_create("test.1", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue2 = dispatch_queue_create("test.2", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue3 = dispatch_queue_create("test.3", DISPATCH_QUEUE_SERIAL);
    
    dispatch_set_target_queue(queue1, targetQueue);
    dispatch_set_target_queue(queue2, targetQueue);
    dispatch_set_target_queue(queue3, targetQueue);
    
    
    dispatch_async(queue1, ^{
        NSLog(@"1 in");
        [NSThread sleepForTimeInterval:3.f];
        NSLog(@"1 out");
    });
    
    dispatch_async(queue2, ^{
        NSLog(@"2 in");
        [NSThread sleepForTimeInterval:2.f];
        NSLog(@"2 out");
    });
    
    dispatch_async(queue3, ^{
        NSLog(@"3 in");
        [NSThread sleepForTimeInterval:1.f];
        NSLog(@"3 out");
    });

5:信号量

    dispatch_semaphore_t semaphore = dispatch_semaphore_create(6);   //括号中填几,就可以有几个任务同时并行.
    
    for (int i = 0; i < 100; i++)
    {
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            
            sleep(2);
            
            NSLog(@"index = %d",i);
            
            //通知信号量,semaphore的value会自动加1.
            dispatch_semaphore_signal(semaphore);
    
            //下面是semaphore的数据.value是信号量当前的值.orig是创建的时候有多少值.
            //{ xrefcnt = 0x1, refcnt = 0x1, suspend_cnt = 0x0, locked = 0, port = 0x0, value = 2, orig = 3 }

        });
    }

6:dispatch_barrier_async

//    作用是在并行队列中，等待前面两个操作并行操作完成，再执行后面的输出
    dispatch_queue_t queue6 =dispatch_queue_create("gcdtest.zfl.demo",DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue6, ^{
        
        [NSThread sleepForTimeInterval:2];
        
        NSLog(@"dispatch_async1");
        
    });
    
    dispatch_async(queue6, ^{
        
        NSLog(@"dispatch_async2");
        
    });
    
    dispatch_barrier_async(queue6, ^{
        
        NSLog(@"dispatch_barrier_async");
        
    });
    
    dispatch_async(queue6, ^{
        
        NSLog(@"dispatch_async3");
        
    });

7:dispatch_after

//延迟2.0s执行
    
    int64_t delayInSeconds = 2.0;
    
    dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW,delayInSeconds * NSEC_PER_SEC);
    
    dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
        
        //do something...
        

8:dispatch_queue_create

 

    DISPATCH_QUEUE_SERIAL

    //NULL默认的是 DISPATCH_QUEUE_SERIAL
    NSLog(@"=====Concurrent Diapatch Queue 并发队列,一个队列触发多个线程=====");

    //创建并发队列  
    dispatch_queue_t concurrentDiapatchQueue=dispatch_queue_create("com.test.queue", DISPATCH_QUEUE_CONCURRENT);  
    //使用队列  
    dispatch_async(concurrentDiapatchQueue, ^{  
        NSLog(@"1");  
    });  
    dispatch_async(concurrentDiapatchQueue, ^{  
        sleep(2);  
        NSLog(@"2");  
    });  
    dispatch_async(concurrentDiapatchQueue, ^{  
        sleep(1);  
        NSLog(@"3");  
    });  

   

    DISPATCH_QUEUE_CONCURRENT

    NSLog(@"=====Concurrent Diapatch Queue 并发队列,一个队列触发多个线程=====");

    //创建并发队列  
    dispatch_queue_t concurrentDiapatchQueue=dispatch_queue_create("com.test.queue", DISPATCH_QUEUE_CONCURRENT);  
    //使用队列  
    dispatch_async(concurrentDiapatchQueue, ^{  
        NSLog(@"1");  
    });  
    dispatch_async(concurrentDiapatchQueue, ^{  
        sleep(2);  
        NSLog(@"2");  
    });  
    dispatch_async(concurrentDiapatchQueue, ^{  
        sleep(1);  
        NSLog(@"3");  
    });