GCD详解

作者: 物非0人非 | 来源:发表于2021-12-01 14:48 被阅读0次

image.png

前言

Grand Central Dispatch（GCD）是 Apple开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在Mac OS X 10.6 雪豹中首次推出，也可在iOS 4 及以上版本使用。

GCD的特点

GCD会自动利用更多的CPU内核。
GCD自动管理线程的生命周期（创建线程，调度任务，销毁线程等）。
程序员只需要告诉GCD 想要如何执行什么任务，不需要编写任何线程管理代码。

全局并发队列的优先级

# iOS 8 服务质量
QOS_CLASS_USER_INTERACTIVE 用户交互(希望线程快速被执行,不要用好使的操作)
QOS_CLASS_USER_INITIATED 用户需要的(同样不要使用耗时操作)
QOS_CLASS_DEFAULT 默认的(给系统来重置队列的)
QOS_CLASS_UTILITY 使用工具(用来做耗时操作)
QOS_CLASS_BACKGROUND 后台
QOS_CLASS_UNSPECIFIED 没有指定优先级

# iOS 7 调度的优先级
DISPATCH_QUEUE_PRIORITY_HIGH 2 高优先级
DISPATCH_QUEUE_PRIORITY_DEFAULT 0 默认优先级
DISPATCH_QUEUE_PRIORITY_LOW (-2) 低优先级
DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN 后台优先级

提示:尤其不要选择BACKGROUND 优先级,服务质量,线程执行会慢到令人发指!!!

队列组 dispatch_group，关键词有

dispatch_group_async
dispatch_group_notify
dispatch_group_enter
dispatch_group_leave
dispatch_group_wait

延时执行 常用方法

//方法1
[self performSelector:@selector(run) withObject:nil afterDelay:2.0];

//方法2
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

});

GCD 线程间通信

dispatch_async(dispatch_get_global_queue(0, 0), ^{
      //做其他事。。。。。

      //回主线程
      dispatch_async(dispatch_get_main_queue(), ^{
       
      })
})

使用dispatch_once 函数能保证某段代码在程序运行过程中只被执行一次

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
//只执行一次的代码（这里面默认是线程安全的，内部加了锁，应该是互斥锁）
});
使用dispatch_apply函数能进行快速迭代遍历
dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index) {
//执行10次代码，index顺序不确定
})

一：串行同步

/** 串行同步: 执行完一个任务，再执行下一个任务。不开启新线程。 */
- (void)syncSerial {
     NSLog(@"\n\n**************串行同步***************\n\n");
    // 串行队列  DISPATCH_QUEUE_SERIAL 串行
    dispatch_queue_t queue = dispatch_queue_create("XYText", DISPATCH_QUEUE_SERIAL);
    // 同步执行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步2   %@",[NSThread currentThread]);
        }
    });
    
    /*
     输入结果为顺序执行，都在主线程：
    
     串行同步1   {number = 1, name = main}
     串行同步1   {number = 1, name = main}
     串行同步1   {number = 1, name = main}
     串行同步2   {number = 1, name = main}
     串行同步2   {number = 1, name = main}
     串行同步2   {number = 1, name = main}

     */
}

二：串行异步

/** 串行异步  开启新线程，但因为任务是串行的，所以还是按顺序执行任务 */
- (void)asyncSerial {
     NSLog(@"\n\n**************串行异步***************\n\n");
     // 串行队列  DISPATCH_QUEUE_SERIAL 串行
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    
    // 异步执行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行异步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行异步2   %@",[NSThread currentThread]);
        }
    });
 /*
  
  输入结果为顺序执行，有不同线程：

  串行异步1   {number = 3, name = (null)}
  串行异步1   {number = 3, name = (null)}
  串行异步1   {number = 3, name = (null)}
  串行异步2   {number = 3, name = (null)}
  串行异步2   {number = 3, name = (null)}
  串行异步2   {number = 3, name = (null)}
  
  */
}

三：并发同步

/** 并发同步 因为是同步的，所以执行完一个任务，再执行下一个任务。不会开启新线程 */
- (void)syncConcurrent {
    NSLog(@"\n\n**************并发同步***************\n\n");
     // 并发队列  DISPATCH_QUEUE_CONCURRENT 并发
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
 
    // 同步执行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发同步2   %@",[NSThread currentThread]);
        }
    });

    /*
     输入结果为顺序执行，都在主线程：
     
     并发同步1   {number = 1, name = main}
     并发同步1   {number = 1, name = main}
     并发同步1   {number = 1, name = main}
     并发同步2   {number = 1, name = main}
     并发同步2   {number = 1, name = main}
     并发同步2   {number = 1, name = main}
    
     */
    
}

四：并发异步

/** 并发异步 任务交替执行，开启多线程。 */
-(void)asyncConcurrent{
    NSLog(@"\n\n**************并发异步***************\n\n");
    // 并发队列 DISPATCH_QUEUE_CONCURRENT 并发
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    
    // 异步执行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发异步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发异步2   %@",[NSThread currentThread]);
        }
    });
   
    /*
     输入结果为无序执行，有多条线程：
     
     并发异步1   {number = 3, name = (null)}
     并发异步2   {number = 4, name = (null)}
     并发异步1   {number = 3, name = (null)}
     并发异步2   {number = 4, name = (null)}
     并发异步1   {number = 3, name = (null)}
     并发异步2   {number = 4, name = (null)}
     
     */
}

五：主队列同步

/** 主队列同步 如果在主线程中运用这种方式，则会发生死锁，程序崩溃。 */
-(void)syncMain {
    NSLog(@"\n\n**************主队列同步,放到主线程会死锁, 程序崩溃***************\n\n");
    // 主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主队列同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主队列同步2   %@",[NSThread currentThread]);
        }
    });
   
}

六：主队列异步

/** 主队列异步 在主线程中任务按顺序执行 */
- (void)asyncMain {
    NSLog(@"\n\n**************主队列异步***************\n\n");
    // 主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主队列异步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主队列异步2   %@",[NSThread currentThread]);
        }
    });

    /*
     输入结果为在主线程中按顺序执行：
     
     主队列异步1   {number = 1, name = main}
     主队列异步1   {number = 1, name = main}
     主队列异步1   {number = 1, name = main}
     主队列异步2   {number = 1, name = main}
     主队列异步2   {number = 1, name = main}
     主队列异步2   {number = 1, name = main}
     
     */
}

七：GCD线程之间的通讯

/**
 开发中需要在主线程上进行UI的相关操作，通常会把一些耗时的操作放在其他线程，比如说图片文件下载等耗时操作。
 当完成了耗时操作之后，需要回到主线程进行UI的处理，这里就用到了线程之间的通讯。
 */

- (IBAction)communicationBetweenThread:(id)sender {
    // 异步
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 耗时操作放在这里，例如下载图片。（运用线程休眠两秒来模拟耗时操作）
        [NSThread sleepForTimeInterval:2];
        NSString *picURLStr = @"http://www.bangmangxuan.net/uploads/allimg/160320/74-160320130500.jpg";
        NSURL *picURL = [NSURL URLWithString:picURLStr];
        NSData *picData = [NSData dataWithContentsOfURL:picURL];
        UIImage *image = [UIImage imageWithData:picData];
        
        // 回到主线程处理UI
        dispatch_async(dispatch_get_main_queue(), ^{
            // 在主线程上添加图片
           // self.imageView.image = image;
        });
    });
}

八：GCD栅栏

栅栏 : 将两组异步执行的操作组给分割起来。等第一组执行完再执行第二组。dispatch_barrier_async

/**
当任务需要异步进行，但是这些任务需要分成两组来执行，第一组完成之后才能进行第二组的操作。这时候就用了到GCD的栅栏方法dispatch_barrier_async。
 
 */
- (IBAction)barrierGCD:(id)sender {
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    
    // 异步执行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步2   %@",[NSThread currentThread]);
        }
    });
    
    dispatch_barrier_async(queue, ^{
        NSLog(@"------------barrier------------%@", [NSThread currentThread]);
        NSLog(@"******* 并发异步执行，但是34一定在12后面 *********");
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步3   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步4   %@",[NSThread currentThread]);
        }
    });
    
    /*
     上面代码的打印结果如下，开启了多条线程，所有任务都是并发异步进行。但是第一组完成之后，才会进行第二组的操作。
     栅栏：并发异步1   {number = 3, name = (null)}
     栅栏：并发异步2   {number = 6, name = (null)}
     栅栏：并发异步1   {number = 3, name = (null)}
     栅栏：并发异步2   {number = 6, name = (null)}
     栅栏：并发异步1   {number = 3, name = (null)}
     栅栏：并发异步2   {number = 6, name = (null)}
     ------------barrier------------{number = 6, name = (null)}
     ******* 并发异步执行，但是34一定在12后面 *********
     栅栏：并发异步4   {number = 3, name = (null)}
     栅栏：并发异步3   {number = 6, name = (null)}
     栅栏：并发异步4   {number = 3, name = (null)}
     栅栏：并发异步3   {number = 6, name = (null)}
     栅栏：并发异步4   {number = 3, name = (null)}
     栅栏：并发异步3   {number = 6, name = (null)}
     */
}

九： GCD延时执行

/**当需要等待一会再执行一段代码时，就可以用到这个方法了：dispatch_after。*/
-(void)yanshhi{
  
   dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 5秒后异步执行
        NSLog(@"我已经等待了5秒！");
    });

//    GCD实现代码只执行一次
//    使用dispatch_once能保证某段代码在程序运行过程中只被执行1次。可以用来设计单例。
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        
        NSLog(@"程序运行过程中我只执行了一次！");
    });
}

十： GCD队列组

关键词有

dispatch_group_async
dispatch_group_notify
dispatch_group_enter
dispatch_group_leave
dispatch_group_wait

/**
 异步执行几个耗时操作，当这几个操作都完成之后再回到主线程进行操作，就可以用到队列组了。
 
 队列组有下面几个特点：
 
 所有的任务会并发的执行(不按序)。
 所有的异步函数都添加到队列中，然后再纳入队列组的监听范围。
 使用dispatch_group_notify函数，来监听上面的任务是否完成，如果完成, 就会调用这个方法。
 */

/**
 * 队列组 dispatch_group_notify
 */
- (void)groupNotify {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"group---begin");
    
    dispatch_group_t group =  dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的异步任务 1、任务 2 都执行完毕后，回到主线程执行下边任务
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程

        NSLog(@"group---end");
    });
}

十一： GCD线程之间的依赖关系

a任务开始执行的前提是b任务执行完成,
c任务开始执行需要等a、b两个异步任务完成，
即a依赖于b，c又依赖a，b，这种需求我们可以使用的GCD来处理。

//创建分组
 dispatch_group_t group =dispatch_group_create();
 //创建队列
 dispatch_queue_t queue =dispatch_queue_create("queue",DISPATCH_QUEUE_CONCURRENT);
  //往分组中添加任务
 dispatch_group_async(group, queue, ^{
  [NSThreadsleepForTimeInterval:2];//模拟耗时操作
   NSLog(@"11111 %@", [NSThreadcurrentThread]);
 });

 //往分组中添加任务
 dispatch_group_async(group, queue, ^{
  [NSThreadsleepForTimeInterval:1];//模拟耗时操作
   NSLog(@"2222 %@", [NSThreadcurrentThread]);
 });

 //分组中任务完成以后通知该block执行
 dispatch_group_notify(group, queue, ^{
  NSLog(@"完成 %@", [NSThreadcurrentThread]);
  dispatch_async(dispatch_get_main_queue(), ^{
  NSLog(@"通知主线程刷新UI %@",[NSThreadcurrentThread]);
 });

 });

// 执行结果:

2017-10-24 11:33:40.426 iOSTest[34497:828682] 2222 0x600000260080>{number = 3, name = (null)} 
2017-10-24 11:33:41.426 iOSTest[34497:828660] 11111 0x608000261d80>{number = 4, name = (null)} 
2017-10-2411:33:41.427 iOSTest[34497:828660] 完成 0x608000261d80>{number = 4, name = (null)} 
2017-10-2411:33:41.427 iOSTest[34497:828365] 通知主线程刷新UI 0x60800007b980>{number = 1, name = main}
这样我们使用group可以实现几个任务之间的依赖关系。

有时我们的任务一层一层的嵌套了多个Block，这个时候，就应该使用如下代码方式：

    //创建分组
    dispatch_group_t group =dispatch_group_create();

    //创建队列
    dispatch_queue_t queue =dispatch_queue_create("queue",DISPATCH_QUEUE_CONCURRENT);

    //往分组中添加任务
    dispatch_group_async(group, queue, ^{
         void (^task)(void) = ^{
            [NSThreadsleepForTimeInterval:2];//模拟耗时操作
             NSLog(@"11111 %@", [NSThreadcurrentThread]);
      };

        dispatch_async(dispatch_get_global_queue(0,0), task);
            NSLog(@"11111---- %@", [NSThreadcurrentThread]);
    });

    //往分组中添加任务
    dispatch_group_async(group, queue, ^{
        void (^task)(void) = ^ {
            [NSThreadsleepForTimeInterval:1];//模拟耗时操作
             NSLog(@"2222 %@", [NSThreadcurrentThread]);
        };

        dispatch_async(dispatch_get_global_queue(0,0), task);
            NSLog(@"2222------- %@", [NSThreadcurrentThread]);
      });

    //分组中任务完成以后通知该block执行
    dispatch_group_notify(group, queue, ^{
           NSLog(@"完成 %@", [NSThreadcurrentThread]);
         dispatch_async(dispatch_get_main_queue(), ^{
           NSLog(@"通知主线程刷新UI %@", [NSThreadcurrentThread]);
       });
    });

执行结果：

2017-10-24 11:44:06.447 iOSTest[34981:881063] 2222------- {number = 4, name = (null)}
2017-10-2411:44:06.447 iOSTest[34981:881046] 11111---- {number = 3, name = (null)}
2017-10-24 11:44:06.448iOSTest[34981:881046] 完成 0x600000071f40>{number = 3, name = (null)} 
2017-10-24 11:44:06.450iOSTest[34981:880987] 通知主线程刷新UI 0x60000006c340>{number = 1, name = main}
 2017-10-2411:44:07.450 iOSTest[34981:881064] 2222 0x6000000708c0>{number = 5, name = (null)} 
2017-10-2411:44:08.452 iOSTest[34981:881049] 11111 0x61000006d5c0>{number = 6, name = (null)}

根据执行结果可以看出，当主线程执行的时候，然而其他两个任务中并没有真正的完成，因为另外两个任务中嵌套了子任务，那问题来了，其他两个任务还没有完成就执行主线程，但是我们需要的是其他两个任务完成才需要执行主线程，别急，group给我们提供了dispatch_group_enter()与dispatch_group_leave()方法来组合运用，值得注意的是，这两个方法一定需要成对使用，要不然有时间又出现一些莫名其妙的bug问题。
代码如下:

 //创建分组
 dispatch_group_t group =dispatch_group_create();
 //创建队列
 dispatch_queue_t queue =dispatch_queue_create("queue",DISPATCH_QUEUE_CONCURRENT);

 //往分组中添加任务
 dispatch_group_enter(group);

    dispatch_async(queue, ^{
     void (^task)(void) = ^{
        [NSThreadsleepForTimeInterval:2];//模拟耗时操作
         NSLog(@"11111 %@", [NSThreadcurrentThread]);
         dispatch_group_leave(group);
    };

   dispatch_async(dispatch_get_global_queue(0,0), task);
         NSLog(@"11111---- %@",[NSThreadcurrentThread]);
 });

    //往分组中添加任务
  dispatch_group_enter(group);

  dispatch_async(queue, ^{
    void (^task)(void) = ^ {
         [NSThreadsleepForTimeInterval:1];//模拟耗时操作
         NSLog(@"2222 %@", [NSThreadcurrentThread]);
         dispatch_group_leave(group);
  };

     dispatch_async(dispatch_get_global_queue(0,0), task);
     NSLog(@"2222------- %@", [NSThreadcurrentThread]);
  });

    //分组中任务完成以后通知该block执行
   dispatch_group_notify(group, queue, ^{
       NSLog(@"完成 %@", [NSThreadcurrentThread]);
   dispatch_async(dispatch_get_main_queue(), ^{
       NSLog(@"通知主线程刷新UI %@", [NSThreadcurrentThread]);
   });
 });

执行结果如下：

2017-10-24 11:48:05.641 iOSTest[35128:902591] 11111---- {number = 3, name = (null)}
2017-10-2411:48:05.641 iOSTest[35128:902608] 2222------- {number = 4, name = (null)}
2017-10-24 11:48:06.644iOSTest[35128:902609] 2222 0x60000006cb00>{number = 5, name = (null)} 
2017-10-24 11:48:07.644iOSTest[35128:902593] 11111 0x6080000721c0>{number = 6, name = (null)} 
2017-10-24 11:48:07.644iOSTest[35128:902593] 完成 0x6080000721c0>{number = 6, name = (null)} 
2017-10-24 11:48:07.645iOSTest[35128:902524] 通知主线程刷新UI 0x61000006e280>{number = 1, name = main}

这样我们想要的得到的结果就实现了。

A，B，C三个任务并发执行，但是C要等A，B执行完成之后再执行。

信号量:

// 创建一个信号，value：信号量
dispatch_semaphore_create(<#long value#>)
// 使某个信号的信号量+1
dispatch_semaphore_signal(<#dispatch_semaphore_t dsema#>)
// 某个信号进行等待或等待降低信号量 timeout：等待时间，永远等待为 DISPATCH_TIME_FOREVER
dispatch_semaphore_wait(<#dispatch_semaphore_t dsema#>, <#dispatch_time_t timeout#>)
正常的使用顺序是先降低然后再提高，这两个函数通常成对使用。

两种方法

-(void)dispatch_group_function1
{
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, dispatch_queue_create("com.dispatch.test", DISPATCH_QUEUE_CONCURRENT), ^{
        NSURLRequest *request = [[NSURLRequest alloc] initWithURL:[NSURL URLWithString:@"https://www.baidu.com"]];
        NSURLSessionDownloadTask *task = [[NSURLSession sharedSession] downloadTaskWithRequest:request completionHandler:^(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error) {
            // 请求完成，可以通知界面刷新界面等操作
            NSLog(@"第一步网络请求完成");
            // 使信号的信号量+1，这里的信号量本来为0，+1信号量为1(绿灯)
            dispatch_semaphore_signal(semaphore);
        }];
        [task resume];
        // 以下还要进行一些其他的耗时操作
        NSLog(@"耗时操作继续进行");
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    });
    dispatch_group_async(group, dispatch_queue_create("com.dispatch.test", DISPATCH_QUEUE_CONCURRENT), ^{
        NSURLRequest *request = [[NSURLRequest alloc] initWithURL:[NSURL URLWithString:@"https://www.github.com"]];
        NSURLSessionDownloadTask *task = [[NSURLSession sharedSession] downloadTaskWithRequest:request completionHandler:^(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error) {
            // 请求完成，可以通知界面刷新界面等操作
            NSLog(@"第二步网络请求完成");
            // 使信号的信号量+1，这里的信号量本来为0，+1信号量为1(绿灯)
            dispatch_semaphore_signal(semaphore);
        }];
        [task resume];
        // 以下还要进行一些其他的耗时操作
        NSLog(@"耗时操作继续进行");
        dispatch_semaphore_wait(semaphore,DISPATCH_TIME_FOREVER);
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"刷新界面等在主线程的操作");
    });
}

2019-02-24 18:19:16.251067+0800 Semaphore[33094:12267734] 耗时操作继续进行
2019-02-24 18:19:16.251071+0800 Semaphore[33094:12267735] 耗时操作继续进行
2019-02-24 18:19:16.549563+0800 Semaphore[33094:12267748] 第一步网络请求完成
2019-02-24 18:19:18.091922+0800 Semaphore[33094:12267737] 第二步网络请求完成
2019-02-24 18:19:18.092222+0800 Semaphore[33094:12267662] 刷新界面等在主线程的操作

设定的信号值为2，先执行两个线程，等执行完一个，才会继续执行下一个，保证同一时间执行的线程数不超过2。

dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //任务1
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"run task 1");
        sleep(1);
        NSLog(@"complete task 1");
        dispatch_semaphore_signal(semaphore);
    });
    //任务2
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"run task 2");
        sleep(1);
        NSLog(@"complete task 2");
        dispatch_semaphore_signal(semaphore);
    });
    //任务3
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"run task 3");
        sleep(1);
        NSLog(@"complete task 3");
        dispatch_semaphore_signal(semaphore);
    });
2019-02-24 18:31:02.447769+0800 Semaphore[33286:12284312] run task 1
2019-02-24 18:31:02.447767+0800 Semaphore[33286:12284310] run task 2
2019-02-24 18:31:03.450756+0800 Semaphore[33286:12284312] complete task 1
2019-02-24 18:31:03.450756+0800 Semaphore[33286:12284310] complete task 2
2019-02-24 18:31:03.450997+0800 Semaphore[33286:12284311] run task 3
2019-02-24 18:31:04.454259+0800 Semaphore[33286:12284311] complete task 3

GCD详解

前言

GCD的特点

一：串行同步

二：串行异步

三：并发同步

四：并发异步

五：主队列同步

六：主队列异步

七：GCD线程之间的通讯

八：GCD栅栏

九： GCD延时执行

十： GCD队列组

十一： GCD线程之间的依赖关系

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

ios多线程

GCD详解

前言

GCD的特点

一：串行同步

二：串行异步

三：并发同步

四：并发异步

五： 主队列同步

六：主队列异步

七：GCD线程之间的通讯

八：GCD栅栏

九： GCD延时执行

十： GCD队列组

十一： GCD线程之间的依赖关系

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

ios多线程

五：主队列同步