web-dev-qa-db-ja.com

AlamofireでのNSURLSession同時要求

テストアプリで奇妙な動作を経験しています。同じサーバーに送信する同時GETリクエストは約50個あります。サーバーは、リソースが非常に限られている小さなハードウェア上の組み込みサーバーです。単一の要求ごとにパフォーマンスを最適化するために、次のように_Alamofire.Manager_の1つのインスタンスを構成します。

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

manager.request(...)を使用してリクエストを送信すると、2つのペアでディスパッチされます（予想どおり、Charles HTTPプロキシでチェックされます）。奇妙なことは、最初のリクエストから30秒以内に終了しなかったすべてのリクエストが、（まだ送信されていなくても）同時にタイムアウトのためにキャンセルされることです。動作を示す図を次に示します。

concurrent request illustration

これは予想される動作ですか？リクエストが送信される前にタイムアウトにならないようにするにはどうすればよいですか？

どうもありがとう！

swiftconcurrencynsurlsessionalamofirensurlsessionconfiguration
68
Hannes

はい、これは予想される動作です。 1つの解決策は、カスタム非同期NSOperationサブクラスで要求をラップし、maxConcurrentOperationCountパラメーターではなく、操作キューのHTTPMaximumConnectionsPerHostを使用して同時要求の数を制御することです。 。

元のAFNetworkingは、操作で要求をラップする素晴らしい仕事をしました。しかし、AFNetworkingのNSURLSession実装はこれを実行したことも、Alamofireも実行しませんでした。

RequestをNSOperationサブクラスに簡単にラップできます。例えば：

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 urlString: String
    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(urlString: String, networkOperationCompletionHandler: ((_ responseObject: Any?, _ error: Error?) -> Void)? = nil) {
        self.urlString = urlString
        self.networkOperationCompletionHandler = networkOperationCompletionHandler
        super.init()
    }

    // when the operation actually starts, this is the method that will be called

    override func main() {
        request = Alamofire.request(urlString, 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()
    }
}

その後、50件のリクエストを開始する場合、次のようなことを行います。

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)
}

そうすれば、これらのリクエストはmaxConcurrentOperationCountによって制限され、リクエストがタイムアウトすることを心配する必要はありません。

これはAsynchronousOperation基本クラスの例で、非同期/同時NSOperationサブクラスに関連付けられたKVNを処理します。

//
//  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<T>( block: (Void) -> T) -> T {
        lock()
        let value = block()
        unlock()
        return value
    }
}

このパターンには他にも可能なバリエーションがありますが、（a）trueに対してasynchronousを返すようにしてください。および（b）必要なisFinishedおよびisExecuting KVNを投稿します（概説：の同時実行のための操作の設定セクション 同時実行プログラミングガイド：操作キュー 。

122
Rob