多线程之Semaphore

最新推荐文章于 2022-08-20 19:44:05 发布

原创最新推荐文章于 2022-08-20 19:44:05 发布 · 587 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#GCD #多线程 #信号量 #Semaphore #dispatch_group

学习笔记同时被 2 个专栏收录

23 篇文章

订阅专栏

IOS开发

21 篇文章

订阅专栏

本文探讨了如何使用GCD的Semaphore解决多线程中并发和顺序请求的问题。通过dispatch_group_notify实现并发请求结束后统一操作，利用dispatch_semaphore_create、dispatch_semaphore_signal和dispatch_semaphore_wait进行线程同步。同时提出了如何处理请求失败的情况作为遗留问题。

问题：一个页面有多个请求，拿到所有请求结果后去刷新页面。

1.多个请求并发

2.多个请求顺序请求

我最开始的做法是嵌套请求：

[self request4sPartnerRebateCountQueryCompletionBlock:^(NSError *error) {
        @strongify(self);
        if (!error) {
            
            [self requestLoanPartnerRebateCountQueryCompletionBlock:^(NSError *error) {
                if (block) {
                    block(error);
                }
            }];
        }else {
            if (block) {
                block(error);
            }
        }
       
   }];

思考了一下这样做的不足之处：

1.请求如果多了，需要写许多嵌套的请求

2.请求变成同步的，在网络差的情况下，如果有n个请求，意味着用户要等待n倍请求的时间

为了解决以上问题，寻求更优的方式去了解一下多线程对这个问题的解决方式：

//多个请求结束后统一操作用group实现

enter和leave必须配合使用，有几次enter就要有几次leave，否则group会一直存在。当所有enter的block都leave后，会执行dispatch_group_notify的block。

- (void)group:(void(^)(NSError * error))block {
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_enter(group);
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self request4sPartnerRebateCountQueryCompletionBlock:^(NSError *error) {
            dispatch_group_leave(group);
        }];
        
    });
    
    dispatch_group_enter(group);
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self requestLoanPartnerRebateCountQueryCompletionBlock:^(NSError *error) {
            dispatch_group_leave(group);
        }];
        
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        
        if (block) {
            block(nil);
        }
        
    });
}

只测试到这一种方法可以实现并发请求都拿到结果之后才去执行最后的block

下面的方法是多个请求顺序执行

//多个请求顺序执行用group 配合semaphore实现此处不用信号量会是什么结果呢？

先了解一下信号量的使用

简单来讲信号量为0则阻塞线程，大于0则不会阻塞。则我们通过改变信号量的值，来控制是否阻塞线程，从而达到线程同步。

在GCD中有三个函数是semaphore的操作

dispatch_samaphore_t dispatch_semaphore_create(long value);
传入的参数为long，输出一个dispatch_semaphore_t类型且值为value的信号量。
值得注意的是，这里的传入的参数value必须大于或等于0，否则dispatch_semaphore_create会返回NULL
dispatch_semaphore_signal(dispatch_semaphore_t dsema) 发送信号使传入的信号量dsema的值加1
dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout) 等待信号使传入的信号量dsema的值减1

- (void)gcdSemaphoreMethod:(void(^)(NSError * error))block
{
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{


        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
        [self request4sPartnerRebateCountQueryCompletionBlock:^(NSError *error) {
            dispatch_semaphore_signal(semaphore);
        }];
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);


    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{


        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
        [self requestLoanPartnerRebateCountQueryCompletionBlock:^(NSError *error) {
            dispatch_semaphore_signal(semaphore);
        }];
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);


    });


    dispatch_group_notify(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //界面刷新
        dispatch_async(dispatch_get_main_queue(), ^{
           
            if (block) {
                block(nil);
            }
        });
    });
}

//多个请求顺序执行 用operation实现 这样实现有问题嘛
- (void)operationMethod:(void(^)(NSError * error))block
{
    // 1.任务一
    NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
        [self request4sPartnerRebateCountQueryCompletionBlock:^(NSError *error) {
            if (block && error) {
                block(error);
            }
        }];
    }];
    
    // 2.任务二
    NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
        [self requestLoanPartnerRebateCountQueryCompletionBlock:^(NSError *error) {
            if (block) {
                block(error);
            }
        }];
       
    }];
    
    // 3.设置依赖
    [operation2 addDependency:operation1];// 任务二依赖任务一
    
    // 4.创建队列并加入任务
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    [queue addOperations:@[operation2, operation1] waitUntilFinished:NO];
}

//此方法由于项目中的网络请求 回调是在主线程 信号量等待也在主线程 导致主线程卡死
- (void)semaphoreMethod:(void(^)(NSError * error))block
{
    __block NSInteger count = 0;
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    [self request4sPartnerRebateCountQueryCompletionBlock:^(NSError *error) {
        count++;
        if (count ==2) {
            
            dispatch_semaphore_signal(semaphore);
        }
    }];
    
    [self requestLoanPartnerRebateCountQueryCompletionBlock:^(NSError *error) {
        count++;
        if (count ==2) {
            
            dispatch_semaphore_signal(semaphore);
        }
    }];
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    dispatch_async(dispatch_get_main_queue(), ^{
        
        if (block) {
            block(nil);
        }
    });
    
}

遗留问题：如何实现当其中一个请求失败就不再请求下一个或者并发请求有一个失败就算失败