web-dev-qa-db-fra.com

Comment obtenir le nom de la file d'attente actuel dans Swift 3

Nous avons une fonction comme celle-ci dans Swift 2.2 pour imprimer un message de journalisation avec le thread en cours d'exécution: 

func MyLog(_ message: String) {
    if Thread.isMainThread {
        print("[MyLog]", message)
    } else {
        let queuename = String(UTF8String: dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL))! // Error: Cannot convert value of type '()' to expected argument type 'DispatchQueue?'
        print("[MyLog] [\(queuename)]", message)
    }
}

Ces codes ne sont plus compilés dans Swift 3.0. Comment obtenons-nous le nom de la file d'attente maintenant? 

La question posée sur la manière d'identifier où deux threads sont ou non le même thread: Vérifie si la file d'attente de dispatch est correcte dans Swift 3 . La réponse acceptée suggère d'utiliser setSpecific pour associer une "étiquette" à une file d'attente créée. Cependant, cela ne résout pas le problème ici car nous voulons connaître le nom de la file d'attente. Et la file d'attente peut ne pas être nécessairement créée par nous-mêmes. 

swiftswift3
19
Yuchen Zhong

Comme Brent Royal-Gordon l'a mentionné dans son message on lists.Swift.org, c'est un trou dans la conception actuelle, mais vous pouvez utiliser cette solution de contournement horrible.

  func currentQueueName() -> String? {
        let name = __dispatch_queue_get_label(nil)
        return String(cString: name, encoding: .utf8)
    }
29
Huralnyk

Si vous n'aimez pas les pointeurs et les c-strings non sécurisés, il existe une autre solution sûre:

if let currentQueueLabel = OperationQueue.current?.underlyingQueue?.label {
    print(currentQueueLabel)
    // Do something...
}

Je ne connais pas de cas où le currentQueueLabel sera nil.

5
kelin

Voici une classe d'emballage qui offre une certaine sécurité (révisé à partir d'ici ):

import Foundation

/// DispatchQueue wrapper that acts as a reentrant to a synchronous queue;
/// so callers to the `sync` function will check if they are on the current
/// queue and avoid deadlocking the queue (e.g. by executing another queue
/// dispatch call). Instead, it will just execute the given code in place.
public final class SafeSyncQueue {

    public init(label: String, attributes: DispatchQueue.Attributes) {
        self.queue = DispatchQueue(label: label, attributes: attributes)
        self.queueKey = DispatchSpecificKey<QueueIdentity>()
        self.queue.setSpecific(key: self.queueKey, value: QueueIdentity(label: self.queue.label))
    }

    // MARK: - API

    /// Note: this will execute without the specified flags if it's on the current queue already
    public func sync<T>(flags: DispatchWorkItemFlags? = nil, execute work: () throws -> T) rethrows -> T {
        if self.currentQueueIdentity?.label == self.queue.label {
            return try work()
        } else if let flags = flags {
            return try self.queue.sync(flags: flags, execute: work)
        } else {
            return try self.queue.sync(execute: work)
        }
    }

    // MARK: - Private Structs

    private struct QueueIdentity {
        let label: String
    }

    // MARK: - Private Properties

    private let queue: DispatchQueue
    private let queueKey: DispatchSpecificKey<QueueIdentity>

    private var currentQueueIdentity: QueueIdentity? {
        return DispatchQueue.getSpecific(key: self.queueKey)
    }

}
0
iwasrobbed

Cela fonctionne mieux pour moi:

/// The name/description of the current queue (Operation or Dispatch), if that can be found. Else, the name/description of the thread.
public func queueName() -> String {
    if let currentOperationQueue = OperationQueue.current {
        if let currentDispatchQueue = currentOperationQueue.underlyingQueue {
            return "dispatch queue: \(currentDispatchQueue.label.nonEmpty ?? currentDispatchQueue.description)"
        }
        else {
            return "operation queue: \(currentOperationQueue.name?.nonEmpty ?? currentOperationQueue.description)"
        }
    }
    else {
        let currentThread = Thread.current
        return "UNKNOWN QUEUE on thread: \(currentThread.name?.nonEmpty ?? currentThread.description)"
    }
}



public extension String {

    /// Returns this string if it is not empty, else `nil`.
    public var nonEmpty: String? {
        if self.isEmpty {
            return nil
        }
        else {
            return self
        }
    }
}
0
Ben Leggiero