johnestropia/gcdkit

Grand Central Dispatch simplified with swift.

GCDKit

GCDKit is Grand Central Dispatch simplified with Swift.

• for Swift 1.2: Use version 1.0.1
• for Swift 2.1 / 2.2: Use the master branch

---

Introduction

GCDKit implements the following constructs. To see how they work, jump right to the Common Usage Patterns section below.

• GCDQueue: An abstraction of the dispatch_queue_* API. GCDQueues are expressed as enums, because we typically only need to deal with these queue types:

public enum GCDQueue {
    case Main
    case UserInteractive
    case UserInitiated
    case Default
    case Utility
    case Background
    case Custom(dispatch_queue_t) // serial or concurrent
}

• GCDBlock: A struct that abstracts iOS 8's new dispatch_block_* family of APIs.
• GCDGroup: An abstraction of the dispatch_group_* API.
• GCDSemaphore: An abstraction of the dispatch_semaphore_* API.

Common Usage Patterns

Here are some common use cases and how you can write them using GCDKit.

Creating and initializing queues

With the iOS SDK:

let mainQueue = dispatch_get_main_queue()
let defaultQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
let customSerialQueue = dispatch_queue_create("mySerialQueue", DISPATCH_QUEUE_SERIAL)
let customConcurrentQueue = dispatch_queue_create("myConcurrentQueue", DISPATCH_QUEUE_CONCURRENT)

With GCDKit:

let mainQueue: GCDQueue = .Main
let defaultQueue: GCDQueue = .Default
let customSerialQueue: GCDQueue = .createSerial("mySerialQueue")
let customConcurrentQueue: GCDQueue = .createConcurrent("myConcurrentQueue")

In addition, custom queues created with dispatch_queue_create(...) typically target a default-priority global queue unless you use the dispatch_set_target_queue(...) API. For example, to raise the priority level of a created queue with the current SDK:

let customConcurrentQueue = dispatch_queue_create("myConcurrentQueue", DISPATCH_QUEUE_CONCURRENT)
dispatch_set_target_queue(customConcurrentQueue, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0))

With GCDKit, you can immediately specify the target queue on creation:

let customConcurrentQueue: GCDQueue = .createConcurrent("myConcurrentQueue", targetQueue: .UserInteractive)

Submitting tasks to queues

With the iOS SDK:

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
    // some heavy work...
    dispatch_async(dispatch_get_main_queue()) {
        // send results to UI
    }
}

With GCDKit you can either start a task chain from GCDBlock.async(...):

GCDBlock.async(.Default) {
    // some heavy work...
}.notify(.Main) {
    // send results to UI
}

or directly from a specific GCDQueue enum value:

GCDQueue.Default.async {
    // some heavy work...
}.notify(.Main) {
    // send results to UI
}

You can chain .notify(...) calls as much as needed.

Launching and reporting completion of a group of tasks

With the iOS SDK:

let dispatchGroup = dispatch_group_create()

dispatch_group_enter(dispatchGroup)
doSomeLongTaskWithCompletion {
    dispatch_group_leave(dispatchGroup)
}

dispatch_group_async(dispatchGroup, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
    // do another long task
}
dispatch_group_async(dispatchGroup, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
    // do yet another long task
}

dispatch_group_notify(dispatchGroup, dispatch_get_main_queue()) {
    // report completion
}

With GCDKit you can still use the usual enter()-leave() pairs and you can chain async calls to the dispatch group:

let dispatchGroup = GCDGroup()

dispatchGroup.enter()
doSomeLongTaskWithCompletion {
    dispatchGroup.leave()
}

dispatchGroup.async(.Default) {
    // do another long task
}.async(.Default) {
    // do yet another long task
}.notify(.Main) {
    // report completion
}

Semaphores

With the iOS SDK:

let numberOfIterations: UInt = 10
let semaphore = dispatch_semaphore_create(Int(numberOfIterations))

dispatch_apply(numberOfIterations, dispatch_queue_create("myConcurrentQueue", DISPATCH_QUEUE_CONCURRENT)) {
    (iteration: UInt) -> Void in

    // do work for iteration
    dispatch_semaphore_signal(semaphore)
}

dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER)

With GCDKit:

let numberOfIterations: UInt = 10
let semaphore = GCDSemaphore(numberOfIterations)

GCDQueue.createConcurrent("myConcurrentQueue").apply(numberOfIterations) {
    (iteration: UInt) -> Void in

    // do work for iteration
    semaphore.signal()
}

semaphore.wait()

Contributions

Feel free to report any issues or send suggestions!

License

GCDKit is released under an MIT license. See the LICENSE file for more information

gcdkit's Issues

OS X support?

Hi John,

GCDKit is a good library when using swift. I'm just wondering whether it supports osx platform, since the framework that GCDKit needs is Foundation only.

EXC_BAD_INSTRUCTION on dispatch_block_notify

Im getting an EXC_BAD_INSTRUCTION on GCDBlock.notify when in calls dispatch_block_notify.
The calling cod looks like this:

GCDBlock.async(.Default) {
            ... does she work ...
        }.notify(.Main) {

        }

Any idea?
(Im using Xcode 7.0.1)

Swift3

Hi @JohnEstropia,

can you tell me something about Swift3 migration of GCDKit?

nice kit. any sample about task queue?

uploadQueen = GDDQueue("upload")
uploadQueen.addTask([task1, task2, task3]).notify({

all task finished!

})

like this

Can't build with xcode 6.4

Hi I am trying to use your latest Pod (GCDKit 1.1.1) but I can't get it to build with Xcode Version 6.4 (6E35b) for iOS 8. I get 63 issues and they seem to be based around @available(iOS, introduced=7.0) Any help would be great.

ITMS-90362 error when using the library and uploading to itunesconnect

The project needs to be updated to have a minimum ios version of 8.0
As a reference, the same issue appeared on Alamofire, here's the link: Alamofire/Alamofire#352
attached is the error from the binary upload

In the meantime i'll create a fork and update the settings on it.

Using 1.2.2 version of the lib.

As i see you have 2 targets on the library, but they build the same framework, overwriting the right one, i'll remove the ios7 target on my fork and build it.

assert and/or balance suspend-resume and wait-signal calls

Is this project being actively developed still?

Hi John,

I really like your GCDKit interfaces. I'd like to make a few initial changes and additions. Add GCD Timer support, etc. We'll probably be making a lot of changes over the long haul that we're using it, but those are the immediate needs right now. I don't want to burden you with change requests, or hi-jack your project, so my options are to either fork it, or adopt it and give it a new name (your name and license to remain intact of course). Do you have any preference on this?

Thanks!

Brandon

Priority support for queues

Hi,

can you add support for priorities?
At the moment I've to do this:

dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0)

to get a low priority queue.

With GCDKit in use:

GCDQueue.Custom(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0)).async {}

but it should be like this:

GCDQueue.GlobalWithPriority(.LowPrority).async {}