Question

我想运行一些相互依赖的任务，所以应该按顺序执行。目前，它阻止我的UI线程，并且在订购时也存在一些问题。

关于这个的几个问题：

任务未按正确顺序执行。如果我们希望他们一个接一个地执行，那么会发生什么变化
代码是根据内存使用情况和资源消耗进行优化的吗？如何使其更加优化？
我们是否还需要函数调用中的全局队列，如下面的代码所示？

以下是我的代码详细信息。我创建了一些串行队列，如下所示：

var Q0_sendDisplayName=dispatch_queue_create("Q0_sendDisplayName",DISPATCH_QUEUE_SERIAL)
var Q1_fetchFromDevice=dispatch_queue_create("fetchFromDevice",DISPATCH_QUEUE_SERIAL)
var Q2_sendPhonesToServer=dispatch_queue_create("sendPhonesToServer",DISPATCH_QUEUE_SERIAL)

我知道串行队列按顺序执行任务，所以我在串行队列上调用了我的任务。这是我的代码：

  dispatch_sync(Q0_sendDisplayName,
        {
            self.sendNameToServer(displayName){ (result) -> () in

                dispatch_sync(self.Q1_fetchFromDevice,
                    {
                         self.SyncfetchContacts({ (result) -> () in


                            dispatch_sync(self.Q2_sendPhonesToServer,
                                {       self.SyncSendPhoneNumbersToServer(self.syncPhonesList, completion: { (result) in



                                                //.......
                                                //....

这些函数中的代码也在全局队列上运行。不知道这是否是一种正确的编码方式。我已经使用完成处理程序来通知该方法已完成执行。这是function1的代码：

  func sendNameToServer(var displayName:String,completion:(result:Bool)->())
  {
   Alamofire.request(.POST,"\(urlToSendDisplayName)",headers:header,parameters:["display_name":displayName]).responseJSON{
            response in
            switch response.result {
                 case .Success:
                   return completion(result: true) //......

这是function2的代码。这个函数只要它读取整个联系人书籍，所以我把它放在全局队列中（不知道它是否正确）。我在主队列上调用完成处理程序。这是代码：

func SyncfetchContacts(completion:(result:Bool)->())
{
    let contactStore = CNContactStore()

    var keys = [CNContactGivenNameKey, CNContactFamilyNameKey, CNContactEmailAddressesKey, CNContactPhoneNumbersKey, CNContactImageDataAvailableKey,CNContactThumbnailImageDataKey, CNContactImageDataKey]
    dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)){

    do {

         try contactStore.enumerateContactsWithFetchRequest(CNContactFetchRequest(keysToFetch: keys)) { (contact, pointer) -> Void in
            if (contact.isKeyAvailable(CNContactPhoneNumbersKey)) {
                for phoneNumber:CNLabeledValue in contact.phoneNumbers {
                    let a = phoneNumber.value as! CNPhoneNumber

        }
        }
        }
        dispatch_async(dispatch_get_main_queue())
        {
            completion(result: true)
        }
        }
 //........

这是function3的代码，它再次在里面有一个全局队列（不知道它是否正确）并在主队列上调用完成处理程序。

func SyncSendPhoneNumbersToServer(phones:[String],completion: (result:Bool)->()){
   Alamofire.request(.POST,"\(url)",headers:header,parameters:["display_name":displayName]).responseJSON{
        response in
        switch response.result {
             case .Success:
                       dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0))
            {
              //enter some large data in database in a loop
                dispatch_async(dispatch_get_main_queue())
               {
               return completion(result: true)
               }


             }//......

Answer 1

在SyncfetchContacts中，您在contactStore.enumerateContactsWithFetchRequest完成之前调用完成处理程序，在完成关闭之外。

只需将其移到那里：

func SyncfetchContacts(completion:(result:Bool)->()) {

    ...

    do {

        try contactStore.enumerateContactsWithFetchRequest(CNContactFetchRequest(keysToFetch: keys)) { (contact, pointer) -> Void in
            if (contact.isKeyAvailable(CNContactPhoneNumbersKey)) {
                for phoneNumber:CNLabeledValue in contact.phoneNumbers {
                    let a = phoneNumber.value as! CNPhoneNumber

                }
            }
            // here ...
            dispatch_async(dispatch_get_main_queue()) {
                completion(result: true)
            }
        }
// ... not here.
//            dispatch_async(dispatch_get_main_queue()) {
//                completion(result: true)
//            }
    }
}

如何在iOS中运行相互依赖的运行任务

1 个答案: