Swift: Замедление нескольких вызовов в WebService

Question

Я работаю над приложением, которое отправляет несколько запросов в веб-службу. По мере того как я углубляюсь в развитие, я нахожу, что веб-сервис становится перегруженным, и мне нужно немного замедлить работу. Я хотел бы отправить каждый запрос в Web-сервис индивидуально и дождаться, пока предыдущий не завершится до отправки следующего. Вот функция, которая использует цикл, чтобы сделать звонки в WebService:

func syncronize(){ 

    for operation in syncOperations{ 
     switch operation{ 
      case "listPhone": 
      let listRequest = WSListRequest(requestType: operation, searchCriteria: [SearchCriteria(name: "name", value: "%")], returnTags: []) 
      _ = HTTPPost(method: "POST", body: listRequest.xml, operation: operation, credentials: creds) 
     default: 
      let listRequest = WSLListRequest(requestType: operation, searchCriteria: [SearchCriteria(name: "name", value: "%")], returnTags: ["name"]) 
      _ = HTTPPost(method: "POST", body: listRequest.xml, operation: operation, credentials: creds) 
     } 
    } 
} 

Функция HttpPost выглядит следующим образом:

class HTTPPost: NSObject, URLSessionDelegate { 

var componentDebug = false 
var user = String() 
var password = String() 
var server = String() 
var port = String() 
var body = NSString() 
var response = Data() 

init(method: String, body: NSString, operation: String, credentials: WSCredential){ 
    super.init() 
    let bodyData = body.data(using: String.Encoding.utf8.rawValue) 

    let config = URLSessionConfiguration.default 
    let userPasswordString = NSString(format: "%@:%@", credentials.userName, credentials.password) 
    let userPasswordData = userPasswordString.data(using: String.Encoding.utf8.rawValue) 
    let base64EncodedCredential = userPasswordData!.base64EncodedString(options: NSData.Base64EncodingOptions.lineLength64Characters) 
    let authString = "Basic \(base64EncodedCredential)" 
    config.httpAdditionalHeaders = ["Authorization" : authString, "Content-Type" : "text/xml;charset=UTF-8"] 
    config.timeoutIntervalForRequest = 10.0 

    // create the user request 
    let urlString = NSString(format: "https://%@:%@/ws/", credentials.server, credentials.port) 
    let url = URL(string: urlString as String) 
    var request = URLRequest(url: url!) 
    request.httpMethod = method 
    request.httpBody = bodyData 
    request.setValue("Basic \(base64EncodedCredential)", forHTTPHeaderField: "Authorization") 
    let session = Foundation.URLSession(configuration: config, delegate: self, delegateQueue:OperationQueue.main) 

    _ = session.dataTask(with: request, completionHandler: { (data, response, error) in 

     let responseParser = XMLParser(data: data!) 
     let responseParserDelegate = XMLResponseParser(operation: operation) 
     responseParser.delegate = responseParserDelegate 
     responseParser.parse() 

     // DEBUGGING OPTIONS 
     //print(response) 
     //print(NSString(data: data!, encoding: NSUTF8StringEncoding)) 
     DispatchQueue.main.async(execute: { 
      self.response = data! 
     }) 


    }).resume() 
} 



func urlSession(_ session: URLSession, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) { 
    completionHandler(Foundation.URLSession.AuthChallengeDisposition.useCredential, URLCredential(trust: challenge.protectionSpace.serverTrust!)) 
} 
} 

Я новичок, когда речь идет о программировании и асинхронного может использовать некоторую помощь. Заранее спасибо.

Answer 1

Используйте семафор, чтобы одна задача не начиналась до тех пор, пока не закончится предыдущая. Вот демо

// The semaphore value is like the size of a token pool. After you've taken 
// all the tokens in the pool, you must wait until a task returns its token 
// back to the pool. Here we only have 1 token (1 request at a time) 
let semaphore = DispatchSemaphore(value: 1) 

// task1 is a request that will take at least 5 seconds to respond 
let task1 = URLSession.shared.dataTask(with: URL(string: "https://httpbin.org/delay/5")!) { data, response, error in 
    print("Task1 is done") 
    semaphore.signal() // release the token 
} 

// task2 is a faster request 
let task2 = URLSession.shared.dataTask(with: URL(string: "https://httpbin.org")!) { data, response, error in 
    print("Task2 is done") 
    semaphore.signal() // release the token 
} 

// Never wait on your main queue, always do that in the background 
DispatchQueue.global(qos: .background).async { 
    semaphore.wait() // take a token, wait if needed. 
        // There will never be a wait here, but included for consistency 
    print("starting task 1") 
    task1.resume() 

    semaphore.wait() // take a token, wait if needed 
    print("starting task 2") 
    task2.resume() 
} 

С семафора, выход можно было бы ожидать:

starting task 1 
Task1 is done 
starting task 2 
Task2 is done 

Вынимают 2 semaphore.wait() линии и может видеть, как оба эти запросы будут отправлены в то же время :

starting task 1 
starting task 2 
Task2 is done 
Task1 is done