Question

从各种日历中提取提醒的线程安全方法是什么？我只是想计算所有提醒并打印它们。印刷工作但计数没有。是否存在竞争条件，因为提取提醒是异步的？

func loadFromCalendars(cals: [EKCalendar], completed: (NSError?)->()) {
    // STEP 1 OF CREATING AN OVERALL COMPLETION BLOCK: Create a dispatch group.
    let loadCalendarServiceGroup: dispatch_group_t = dispatch_group_create()

    // Define errors to be processed when everything is complete.
    // One error per service; in this example we'll have two
    let configError: NSError? = nil
    let preferenceError: NSError? = nil

    var reminderCounter = 0


    let eventStore : EKEventStore = EKEventStore()
    eventStore.requestAccessToEntityType(EKEntityType.Event, completion: {
        granted, error in
        if (granted) && (error == nil) {
            print("granted \(granted)")
            print("error  \(error)")
        }
    })

    // Go through calendars.
    for cal in cals {
        let remindersPredicate = eventStore.predicateForRemindersInCalendars([cal])

        // STEP 2 OF CREATING AN OVERALL COMPLETION BLOCK: Adding tasks to a dispatch group
        dispatch_group_enter(loadCalendarServiceGroup)

        eventStore.fetchRemindersMatchingPredicate(remindersPredicate) {
            // MARK: Begininning of thread

            reminders in

            _ = (reminders!).map {

                // TRYING TO COUNT HERE THE REMINDERS. ALWAYS PRINTS 0!
                reminder -> EKReminder in
                print(reminder.title)
                reminderCounter += 1
                return reminder

            }

            dispatch_async(dispatch_get_main_queue()) {
                self.sendChangedNotification()  // refreshes the UI
            }
        }


        // STEP 3 OF CREATING AN OVERALL COMPLETION BLOCK: Leave dispatch group. This must be done at the end of the completion block.
        dispatch_group_leave(loadCalendarServiceGroup)

        // MARK: End of thread
    }


    // STEP 4 OF CREATING AN OVERALL COMPLETION BLOCK: Acting when the group is finished
    dispatch_group_notify(loadCalendarServiceGroup, dispatch_get_main_queue(), {
        print("************ reminder count: \(reminderCounter) ****************")


        // Assess any errors
        var overallError: NSError? = nil;

        if configError != nil || preferenceError != nil {
            // Either make a new error or assign one of them to the overall error. Use '??', which is the "nil Coalescing Operator". It's syntactic sugar for the longer expression:
            //     overallError = configError != nil ? configError : preferenceError
            overallError = configError ?? preferenceError
        }            // Now call the final completion block


        // Call the completed function passed to loadCalendarHelper. This will contain the stuff that I want executed in the end.
        completed(overallError)
    })
}

修改感谢jtbandes的精彩提示！我简化了我的代码（很多！）一个问题 - 我链接了一些改变结果数据结构的函数。如何在下面的代码中使用groupArrayBy（）线程安全？

public extension SequenceType {
    /// Categorises elements of self into a dictionary, with the keys given by keyFunc       
    func groupArrayBy<U : Hashable>(@noescape keyFunc: Generator.Element -> U) -> [U:[Generator.Element]] {
        var dict: [U:[Generator.Element]] = [:]
        for el in self {
            let key = keyFunc(el)
            if case nil = dict[key]?.append(el) { dict[key] = [el] }
        }
        return dict
    }
}


func loadFromCalendars(cals: [EKCalendar], completed: (NSError?)->()) {
    let configError: NSError? = nil
    let preferenceError: NSError? = nil

    withEstore {        // retrieves the EKEventStore
        estore in
        let predicate = estore.predicateForRemindersInCalendars(cals)
        estore.fetchRemindersMatchingPredicate(predicate) { reminders in
            print("Number of reminders: \(reminders?.count ?? 0)")  // Prints correct result

            let list = (reminders!).map {
                // this map still works, it seems thread-safe
                reminder -> ReminderWrapper in
                return ReminderWrapper(reminder: reminder)  // This still works. ReminderWrapper is just a wrapper class. Not very interesting...
                }.groupArrayBy { $0.reminder.calendar }     // ERROR: groupArrayBy doesn't seem to be thread-safe!

            print("Number of reminders: \(Array(list.values).count)")   // Prints a too low count. Proves that groupArrayBy isn't thread-safe.

            dispatch_async(dispatch_get_main_queue()) {
                self.sendChangedNotification()  // refreshes the UI

                completed(configError ?? preferenceError)
            }
        }
    }
}

Answer 1

应对此代码进行一些更改：

dispatch_group_leave(loadCalendarServiceGroup)必须 fetchRemindersMatchingPredicate块。否则，传递给dispatch_group_notify的块将在提取完成之前执行，这完全违背了使用组的目的。
requestAccessToEntityType调用也是异步的，但您的代码只是在启动访问请求后继续，而不等待它完成。您可能希望将完成块链接在一起。
您要求访问.Event类型，但您可能需要.Reminder。
reminderCounter += 1不是线程安全的。在更改计数器之前，您可能希望dispatch_async进入串行队列（因此线程之间没有争用），或者您可以使用OSAtomicAdd family函数。
我建议你只使用_ = (reminders!).map { reminder in ... }而不是for reminder in reminders { ... }。

然而...

我认为你所做的事情过于复杂。

请注意，predicateForRemindersInCalendars需要数组日历。您只需传递所有日历cals，即可获得包含所有日历的单个谓词，并运行单个查询：

let predicate = eventStore.predicateForRemindersInCalendars(cals)
eventStore.fetchRemindersMatchingPredicate(predicate) { reminders in
    print("Number of reminders: \(reminders?.count ?? 0)")

    dispatch_async(dispatch_get_main_queue()) {
        self.sendChangedNotification()  // refreshes the UI

        completed(configError ?? preferenceError)
    }
}

从Swift的日历中获取提醒

1 个答案:

然而...