GCD封装实现最大并发数

最新推荐文章于 2024-09-12 19:26:25 发布
原创 最新推荐文章于 2024-09-12 19:26:25 发布 · 407 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一个基于Grand Central Dispatch (GCD)的Objective-C并发队列类库——GCDPropertyQueue。该库提供了不同优先级的全局队列、后台队列及主线程队列等，并实现了异步和同步调度方法。

//

//  QDispatchQueue.h

//  GCDPropertyQueue

//

//  Created by maochengfang on 2020/10/28.

//

 

#import <Foundation/Foundation.h>

 

NS_ASSUME_NONNULL_BEGIN

 

@interface QDispatchQueue : NSObject

 

+ (QDispatchQueue *)mainThreadQueue;

+ (QDispatchQueue *)defaultGlobalQueue;

+ (QDispatchQueue *)lowGlobalQueue;

+ (QDispatchQueue *)hightGlobalQueue;

+ (QDispatchQueue *)backGroundGlobalQueue;

 

 

@property (nonatomic, assign, readonly) NSUInteger concurrentCount;

 

- (instancetype)init;

 

- (instancetype)initWithQueue:(dispatch_queue_t)queue;

 

- (instancetype)initWithQueue:(dispatch_queue_t)queue concurrentCount:(NSUInteger)concurrentCount;

 

- (void)sync:(dispatch_block_t)block;

 

- (void)async:(dispatch_block_t)block;

 

@end

 

NS_ASSUME_NONNULL_END

 

//

//  QDispatchQueue.m

//  GCDPropertyQueue

//

//  Created by maochengfang on 2020/10/28.

//

 

#import "QDispatchQueue.h"

 

static const NSUInteger kDefaultConcurrentCount = 1; //默认/最小并发数

static const NSUInteger kGlobalConcurrentCount = 4; //默认全局队列线程并发数

static const NSUInteger kMaxConcurrentCount = 32;    //最大并发数

 

@interface QDispatchQueue ()

 

@property (nonatomic, strong) dispatch_queue_t serialQueue;

@property (nonatomic, strong) dispatch_semaphore_t semaphore;

@property (nonatomic, strong) dispatch_queue_t queue;

@property (nonatomic, assign) NSUInteger concurrentCount;

 

@end

 

@implementation QDispatchQueue

 

+ (QDispatchQueue *)mainThreadQueue{

    static QDispatchQueue *queue;

    static dispatch_once_t onceToken;

    dispatch_once(&onceToken, ^{

        

        queue = [[QDispatchQueue alloc] initWithQueue:dispatch_get_main_queue()];

    });

    return queue;

}

 

+ (QDispatchQueue *)lowGlobalQueue{

    static QDispatchQueue  *queue;

    static dispatch_once_t onceToken;

    

    dispatch_once(&onceToken, ^{

        queue = [[QDispatchQueue alloc] initWithQueue:dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0) concurrentCount:(NSUInteger)kDefaultConcurrentCount];

    });

    return  queue;

}

 

+ (QDispatchQueue *)hightGlobalQueue{

    static QDispatchQueue *queue;

    static dispatch_once_t onceToken;

    dispatch_once(&onceToken, ^{

        queue = [[QDispatchQueue alloc] initWithQueue:dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0) concurrentCount:(NSUInteger)kDefaultConcurrentCount];

    });

    return  queue;

}

 

+ (QDispatchQueue *)backGroundGlobalQueue{

    static QDispatchQueue * queue;

    static dispatch_once_t onceToken;

    

    dispatch_once(&onceToken, ^{

        queue = [[QDispatchQueue alloc] initWithQueue:dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0) concurrentCount:(NSUInteger)kDefaultConcurrentCount];

    });

    

    return  queue;

}

 

 

 

- (instancetype)init{

    return  [self initWithQueue:dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0) concurrentCount:(NSUInteger)kDefaultConcurrentCount];

}

 

- (instancetype)initWithQueue:(dispatch_queue_t)queue{

    return [self initWithQueue:queue concurrentCount:kDefaultConcurrentCount];

}

 

- (instancetype)initWithQueue:(dispatch_queue_t)queue concurrentCount:(NSUInteger)concurrentCount{

    

    self = [super init];

    

    if(self){

        if(!queue){

            _queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

            

        }else{

            _queue = queue;

            

            _concurrentCount = concurrentCount;

            

            if(concurrentCount < kDefaultConcurrentCount){

                concurrentCount = kDefaultConcurrentCount;

            }

            

            _concurrentCount = concurrentCount;

            

            if(!_semaphore){

                _semaphore = dispatch_semaphore_create(concurrentCount);

            }

            

            if(!_serialQueue){

                _serialQueue = dispatch_queue_create([[NSString stringWithFormat:@"com.maozeze.nanhua.serial_%p",self] UTF8String], DISPATCH_QUEUE_SERIAL);

            }

        }

    }

    

    return  self;

}

 

 

 

- (void)sync:(dispatch_block_t)block{

    

    if(!block){

        return;

    }

    

    dispatch_sync(_serialQueue, ^{

       

        dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);  //semaphore -1

        dispatch_sync(self.queue, ^{

            if(block){

                block();

            }

            dispatch_semaphore_signal(self.semaphore); //semaphore +1

        });

    });

    

}

 

- (void)async:(dispatch_block_t)block{

    if(!block){

        return;

    }

    

    dispatch_async(self.serialQueue, ^{

       

        dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER); //semaphore -1

        dispatch_async(self.queue, ^{

            if(block){

                block();

            }

            dispatch_semaphore_signal(self.semaphore); //semaphore +1

        });

    });

}

 

@end

测试异步和同步

- (void)testAsync{

    dispatch_queue_t workConcurrentQueue = dispatch_queue_create("com.jzp.async.queue", DISPATCH_QUEUE_CONCURRENT);

    QDispatchQueue *queue = [[QDispatchQueue alloc]initWithQueue:workConcurrentQueue concurrentCount:3];

    for (NSInteger i = 0; i < 10; i++) {

        [queue async:^{

            NSLog(@"thread-info:%@开始执行任务%d",[NSThread currentThread],(int)i);

            sleep(1);

            NSLog(@"thread-info:%@结束执行任务%d",[NSThread currentThread],(int)i);

        }];

    }

    NSLog(@"异步:主线程任务...");

}

 

- (void)testSync{

    dispatch_queue_t workConcurrentQueue = dispatch_queue_create("com.jzp.sync.queue", DISPATCH_QUEUE_CONCURRENT);

    QDispatchQueue *queue = [[QDispatchQueue alloc]initWithQueue:workConcurrentQueue concurrentCount:1];

    for (NSInteger i = 0; i < 10; i++) {

        [queue sync:^{

            NSLog(@"thread-info:%@开始执行任务%d",[NSThread currentThread],(int)i);

            sleep(1);

            NSLog(@"thread-info:%@结束执行任务%d",[NSThread currentThread],(int)i);

        }];

    }

    NSLog(@"异步:主线程任务...");

}

GCD 深入解析：从使用到底层实现
画个大饼的博客
05-03 1515
Grand Central Dispatch (GCD) 是 Apple 提供的一套强大的并发编程框架，它通过精心设计的分层架构和核心组件，为开发者提供了简单易用的并发编程接口。GCD 的核心优势在于其高效的队列管理、智能的线程池调度、灵活的任务依赖处理以及完善的内存管理机制。在实际应用中，开发者需要根据具体场景选择合适的队列类型：主队列用于 UI 更新，全局队列用于后台任务，自定义队列用于特定业务场景。
Objective-C多线程与并发编程基础及其实现
10-20
NSOperationQueue管理一组NSOperation对象的执行，并提供了控制并发量的选项，比如设置最大并发操作数。NSOperation提供了依赖管理和取消操作的功能，使得开发者能够精确控制任务之间的依赖关系和执行状态。 在...
iOS GCD中控制最大并发数
gcs的博客
03-06 2318
一、概述 在GCD中有两种队列，分别是串行队列和并发队列。在串行队列中，同一时间只有一个任务在执行，不能充分利用多核 CPU 的资源，效率较低。 并发队列可以分配多个线程，同时处理不同的任务；效率虽然提升了，但是多线程的并发是用时间片轮转方法实现的，线程创建、销毁、上下文切换等会消耗CPU 资源。 目前iPhone的处理器是多核（2个、4个），适当的并发可以提高效率，但是无节制地并发，如将大...
GCD编程-控制线程最大并发量之信号量
chenxi506343891的博客
04-24 924
//定义一个信号量，初始化为10 dispatch_semaphore_t semaphore = dispatch_semaphore_create(10);//同时执行100个任务 for (int i = 0; i < 100; i++) { dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAU
iOS实录：GCD使用小结（二）
iOS_开发
07-29 611
点击上方“iOS开发”，选择“置顶公众号” 关键时刻，第一时间送达！ 导语：在GCD的使用中，需要考虑控制最大并发数 和 线程同步这两个问题，本文主要介绍GCD中如何控制最大并发数 。 一、概述 1、GCD并发的困扰 在GCD中有两种队列，分别是串行队列和并发队列。在串行队列中，同一时间只有一个任务在执行，不能充分利用多核 CPU 的资源，效率较低。 并发队
GCD可以设置线程最大并发量
a745050的博客
04-12 954
-(void)dispatchSignal{ //crate的value表示，最多几个资源可访问 dispatch_semaphore_t semaphore = dispatch_semaphore_create(2); dispatch_queue_t quene = dispatch_get_global_queue(DISPATCH_QUEUE...
GCD：semaphore解决同步与异步最大并发数
lcx_love_yx的专栏
04-15 307
#import "Semaphore.h" @implementation Semaphore //参考：https://www.jianshu.com/p/2dd2433e2d4a #pragma - 解决同步问题:任务1、2、3按顺序执行 + (void)syncTest{ dispatch_queue_t queue = dispatch_get_global_queue(DI...
GCD队列自定义并发线程Demo代码解析
- 使用`dispatch_semaphore_t`控制最大并发数，防止资源过度占用。 此外，该Demo还可能涉及GCD的高级特性，如队列优先级设置（通过`dispatch_set_target_queue`调整队列层级）、定时任务（`dispatch_after`延迟执行...
iOS使用GCD控制多线程任务数量的实现方法
通过自定义封装，既保留了GCD的高性能特性，又弥补了其原生不支持最大并发数限制的短板，实现了灵活性与可控性的统一。 在实际应用中，此类工具可广泛应用于以下场景：批量上传用户数据时限制同时连接数，防止...
VHDL实现Booth乘法器与GCD算法设计
在VHDL中设计GCD模块时，通常采用有限状态机（FSM）来控制算法步骤，输入为两个n位二进制数，输出为其最大公约数。电路内部包含比较器、减法器、移位器和控制逻辑，所有操作均在时钟节拍下逐步执行。考虑到实时性和...
iOS控制多线程任务数量
10-14
iOSGCD控制多线程任务数量，直接使用ZKRGlobalQueue^()。
GCD信号量控制并发
ChadPro
06-23 425
例程一：控制线程数量 //信号量控制并发 dispatch_group_t group = dispatch_group_create(); dispatch_semaphore_t semaphore = dispatch_semaphore_create(10); dispatch_queue_t queue = dispatch_get_global_que
GCD 信号量控制并发（dispatch_semaphore）以及dispatch_group_async
iOS开发学习
09-03 3741
1、dispatch_semaphore 当我们在处理一系列线程的时候，当数量达到一定量，在以前我们可能会选择使用NSOperationQueue来处理并发控制，但如何在GCD中快速的控制并发呢？ 答案就是dispatch_semaphore，对经常做unix开发的人来讲，我所介绍的内容可能就显得非常入门级了，信号量在他们的多线程开发中再平常不过了。 信号量是一个整形值并且具有一个初始计数值
BigInteger详解
Michael_yan的专栏
09-13 2822
BigInteger：Immutable arbitrary-precision integers. All operations behave as if BigIntegers were represented in two's-complement notation (like Java's primitive integer types). BigInteger provides an
深入理解Dispatch Queue（一）
热门推荐
BossKai的博客
07-03 1万+
Dispatch Queues提供了一种简单的方式让我们在App中实现异步和并发。任务的概念：一个任务是我们的程序需要执行的一个独立的工作。我们可以通过将相应的代码放到一个函数或一个block中并将其添加到调度队列中来定义任务。可以将调度队列理解为一个管理我们提交过的任务的对象。调度队列遵循先入先出的规则，提交到队列中的任务总是以相同的顺序开始启动的。 GCD为我们提供了三种调度队列
dispatch_get_global_queue() 与dispatch_queue_create(nil, DISPATCH_QUEUE_CONCURRENT)的区别
shn_boy的博客
08-16 2123
Global queues是全局队列是并发队列，并由整个进程共享。进程中存在三个全局队列：高、中（默认）、低三个优先级队列。可以调用dispatch_get_global_queue函数传入优先级来访问队列。 dispatch_queue_create使用户队列，由用户通过dispatch_queue_create来自行创建的串行队列，可以用于完成同步机制
iOS GCD最大并发控制
Rookie的博客
04-13 795
dispatch_semaphore_t sem = dispatch_semaphore_create(1); dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER); 这两句代码为什么会闪退 最后信号数量不对等， dispatch_semaphore_t sem = dispatch_semaphore_create(
iOS高级理论：多线程专题 - (2) GCD信号量的应
长沙火山
02-24 1459
这样做的目的是保证在请求结果没有返回之前，一直让线程等待在那里，这样一个线程的任务一直在等待，就不会算作完成，notify的内容也就不会执行了，直到每个请求的结果都返回了，线程任务才能够结束，这时候notify也才能够执行。对计算机了解的都会知道信号量的作用，当我们多个线程要访问同一个资源的时候，往往会设置一个信号量，当信号量大于0的时候，新的线程可以去操作这个资源，操作时信号量-1，操作完后信号量+1，当信号量等于0的时候，必须等待，所以通过控制信号量，我们可以控制能够同时进行的并发数。
并发编程 - GCD信号量
weixin_39339407的博客
09-12 1226
在本篇博客中，我们详细讨论了GCD信号量的工作原理及其应用场景。通过合理的使用GCD信号量，可以有效地管理并发任务，提升程序的性能和稳定性。然而，我们在使用信号量时需要注意其潜在的挑战，以避免引发性能问题或同步错误。
stl queue
最新发布
03-09
### C++ STL Queue Usage and Examples In C++, `std::queue` is part of the Standard Template Library (STL), which provides a convenient way to implement queues using templates. A queue follows the First-In-First-Out (FIFO) principle where elements are inserted from one end called rear and deleted from another end known as front. To use `std::queue`, include `<queue>` header file. Here’s how one can define and initialize a queue: ```cpp #include <iostream> #include <queue> int main() { std::queue<int> q; } ``` Adding elements into the queue uses member function `push()` or `emplace()`. Removing elements employs `pop()`. Accessing but not removing the first element utilizes `front()`, while checking whether the queue is empty relies on `empty()`. To get the number of elements currently stored within the container adaptor, apply `size()` method[^1]. Below demonstrates basic operations with integers in a queue: ```cpp #include <iostream> #include <queue> void showQueue(std::queue<int> gq){ while (!gq.empty()){ std::cout << '\t' << gq.front(); gq.pop(); } } int main(){ std::queue<int> gquiz; gquiz.push(10); gquiz.push(20); std::cout << "The queue gquiz is : "; showQueue(gquiz); std::cout<<"\ngquiz.size() : "<<gquiz.size(); return 0; } ``` For more complex data structures like strings or custom objects, similar methods apply without modification needed since these functions work generically over different types through template instantiation mechanisms provided by C++. However, when dealing specifically with boolean values inside vectors (`std::vector<bool>`), special attention should be paid due to its unique implementation involving proxies rather than direct storage of bools [^2]. This does not affect standard queues directly unless such specialized containers become involved indirectly via contained elements.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值