Requêtes concurrentes NSURLSession avec Alamofire

Je ressens un comportement étrange avec mon application de test. J’ai environ 50 requêtes GET simultanées que j’envoie au même serveur. Le serveur est un serveur intégré sur un petit matériel avec des ressources très limitées. Afin d’optimiser les performances pour chaque requête, je configure une instance d’ Alamofire.Manager comme suit:

 let configuration = NSURLSessionConfiguration.defaultSessionConfiguration() configuration.HTTPMaximumConnectionsPerHost = 2 configuration.timeoutIntervalForRequest = 30 let manager = Alamofire.Manager(configuration: configuration) 

Lorsque j’envoie les demandes avec manager.request(...) elles sont envoyées par paires de 2 (comme prévu, vérifiées avec Charles HTTP Proxy). Ce qui est étrange, cependant, c’est que toutes les demandes qui ne sont pas terminées dans les 30 secondes qui suivent la première demande sont annulées à cause du délai d’attente au même moment (même si elles n’ont pas encore été envoyées). Voici une illustration présentant le comportement:

illustration de demande simultanée

S’agit-il d’un comportement attendu et comment puis-je m’assurer que les demandes ne recevront pas le délai d’attente avant même d’être envoyées?

Merci beaucoup!

Oui, c’est un comportement attendu. Une solution consiste à envelopper vos demandes dans une sous-classe NSOperation personnalisée et asynchrone, puis à utiliser le maxConcurrentOperationCount de la queue des opérations pour contrôler le nombre de demandes simultanées plutôt que le paramètre HTTPMaximumConnectionsPerHost .

AFNetworking original a fait un excellent travail en encapsulant les requêtes dans les opérations, ce qui a rendu cette opération sortingviale. Mais la NSURLSession œuvre de NSURLSession par NSURLSession ne l’a jamais fait, de même qu’Alamofire.


Vous pouvez facilement envelopper la Request dans une sous-classe NSOperation . Par exemple:

 class NetworkOperation: AsynchronousOperation { // define properties to hold everything that you'll supply when you instantiate // this object and will be used when the request finally starts // // in this example, I'll keep track of (a) URL; and (b) closure to call when request is done private let urlSsortingng: Ssortingng private var networkOperationCompletionHandler: ((_ responseObject: Any?, _ error: Error?) -> Void)? // we'll also keep track of the resulting request operation in case we need to cancel it later weak var request: Alamofire.Request? // define init method that captures all of the properties to be used when issuing the request init(urlSsortingng: Ssortingng, networkOperationCompletionHandler: ((_ responseObject: Any?, _ error: Error?) -> Void)? = nil) { self.urlSsortingng = urlSsortingng self.networkOperationCompletionHandler = networkOperationCompletionHandler super.init() } // when the operation actually starts, this is the method that will be called override func main() { request = Alamofire.request(urlSsortingng, method: .get, parameters: ["foo" : "bar"]) .responseJSON { response in // do whatever you want here; personally, I'll just all the completion handler that was passed to me in `init` self.networkOperationCompletionHandler?(response.result.value, response.result.error) self.networkOperationCompletionHandler = nil // now that I'm done, complete this operation self.completeOperation() } } // we'll also support canceling the request, in case we need it override func cancel() { request?.cancel() super.cancel() } } 

Alors, quand je veux lancer mes 50 demandes, je ferais quelque chose comme ceci:

 let queue = OperationQueue() queue.maxConcurrentOperationCount = 2 for i in 0 ..< 50 { let operation = NetworkOperation(urlString: "http://example.com/request.php?value=\(i)") { responseObject, error in guard let responseObject = responseObject else { // handle error here print("failed: \(error?.localizedDescription ?? "Unknown error")") return } // update UI to reflect the `responseObject` finished successfully print("responseObject=\(responseObject)") } queue.addOperation(operation) } 

De cette façon, ces requêtes seront limitées par le maxConcurrentOperationCount , et nous n’avons pas à nous soucier de la temporisation des requêtes.

Voici un exemple de classe de base AsynchronousOperation , qui prend en charge le KVN associé à la sous-classe NSOperation asynchrone / concurrente:

 // // AsynchronousOperation.swift // // Created by Robert Ryan on 9/20/14. // Copyright (c) 2014 Robert Ryan. All rights reserved. // import Foundation /// Asynchronous Operation base class /// /// This class performs all of the necessary KVN of `isFinished` and /// `isExecuting` for a concurrent `NSOperation` subclass. So, to developer /// a concurrent NSOperation subclass, you instead subclass this class which: /// /// - must override `main()` with the tasks that initiate the asynchronous task; /// /// - must call `completeOperation()` function when the asynchronous task is done; /// /// - optionally, periodically check `self.cancelled` status, performing any clean-up /// necessary and then ensuring that `completeOperation()` is called; or /// override `cancel` method, calling `super.cancel()` and then cleaning-up /// and ensuring `completeOperation()` is called. public class AsynchronousOperation : Operation { private let stateLock = NSLock() private var _executing: Bool = false override private(set) public var isExecuting: Bool { get { return stateLock.withCriticalScope { _executing } } set { willChangeValue(forKey: "isExecuting") stateLock.withCriticalScope { _executing = newValue } didChangeValue(forKey: "isExecuting") } } private var _finished: Bool = false override private(set) public var isFinished: Bool { get { return stateLock.withCriticalScope { _finished } } set { willChangeValue(forKey: "isFinished") stateLock.withCriticalScope { _finished = newValue } didChangeValue(forKey: "isFinished") } } /// Complete the operation /// /// This will result in the appropriate KVN of isFinished and isExecuting public func completeOperation() { if isExecuting { isExecuting = false } if !isFinished { isFinished = true } } override public func start() { if isCancelled { isFinished = true return } isExecuting = true main() } override public func main() { fatalError("subclasses must override `main`") } } /* Copyright (C) 2015 Apple Inc. All Rights Reserved. See LICENSE.txt for this sample's licensing information Abstract: An extension to `NSLock` to simplify executing critical code. From Advanced NSOperations sample code in WWDC 2015 https://developer.apple.com/videos/play/wwdc2015/226/ From https://developer.apple.com/sample-code/wwdc/2015/downloads/Advanced-NSOperations.zip */ import Foundation extension NSLock { /// Perform closure within lock. /// /// An extension to `NSLock` to simplify executing critical code. /// /// - parameter block: The closure to be performed. func withCriticalScope( block: (Void) -> T) -> T { lock() let value = block() unlock() return value } } 

Il existe d'autres variantes possibles de ce modèle, mais assurez-vous simplement que (a) vous retournez true pour asynchronous ; et (b) vous publiez le isExecuting KVN isFinished et isExecuting nécessaire, comme indiqué dans la section Configuration des opérations pour exécution simultanée du Guide de programmation de la concurrence: files d'attente d'opération .