Concurrency and lock in Swift

Question

Premise

We all know there are good numbers and bad numbers in the universe.

I have the following synchronous function

func isGood(number:Int) -> Bool {
    // synchronous connection
    // ...
    // returns a Bool
}

Of course I am not providing the secret implementation here, but you should know that it performs a synchronous internet connection and it does return

true: if the Int received as param is a "good number"
false: otherwise

The problem

Now, given the 100 integers from 0 to 99, I want to know if at least 51 of them are good numbers.

The synchronous approach

I could write something like this.

func majorityIsGood() -> Bool {
    var count = 0
    for i in 0...99 {
        if isGood(i) {
            count++
            if count > 50 {
                return true
            }
        }
    }
    return false
}

But performing 100 (in the worst case scenario) synchronous call to isGood will require too much time. I need the answer as fast as possible.

The asynchronous approach

I would prefer something like this

func majorityIsGood(completion:(good:Bool) -> ()) {
    var goodNums = 0
    var badNums = 0
    var resultFound = false

    for i in 0...99 {
        dispatch_async(DISPATCH_QUEUE_CONCURRENT) {

            let isGood = isGood(i)

            // lineA
            // begin lock on (resultFound)
            if !resultFound {
                if isGood {
                    goodNums++
                } else {
                    badNums++
                }
                if goodNums > 50 || badNums >= 50 {
                    resultFound = true
                    completion(good: goodNums > 50)
                }
            }
            // end lock on (resultFound)
            // lineB
        }
    }
}

Questions

How can I guarantee a synchronous access to the block of code between lineA and lineB in Swift?
And finally, once I get the result, is it possible to kill the concurrent closures that are still being processed?

Thank you in advance.

nRewik · Accepted Answer

serial queue can be used to synchronize access to a specific resource.
I'm not sure. If there is a way to kill the concurrent operation that being dispatched. However, if you just want to stop them. take a look at NSOperation cancellation.

Here's the code

func majorityIsGood( completion: ((good:Bool) -> Void) ) {

    var goodNums = 0
    var badNums = 0
    var resultFound = false

    let serialQueue = dispatch_queue_create("com.unique.myQueue", DISPATCH_QUEUE_SERIAL)

    for i in 0...99 {
        dispatch_async(DISPATCH_QUEUE_CONCURRENT) {

            let _isGood = isGood(i)

            // lineA
            dispatch_async(serialQueue){
                if !resultFound {
                    if _isGood {
                        goodNums++
                    } else {
                        badNums++
                    }
                    if goodNums > 50 || badNums >= 50 {
                        resultFound = true
                        completion(good: goodNums > 50)
                    }
                }
            }
            // lineB
        }
    }
}