Question

我有一个方法应该支持从任何队列调用，并且应该期望。它在后台线程本身运行一些代码，然后在它返回一个值的块参数时使用dispatch_get_main_queue。我不希望它强制它进入主队列，如果不是它进入方法时。有没有办法获得指向当前调度队列的指针？

Answer 1

您可以使用NSOperationQueue。 NSOperationQueue具有类函数[NSOperationQueue currentQueue]，它将当前队列作为NSOperationQueue对象返回。要获取调度队列对象，您可以使用[NSOperationQueue currentQueue].underlyingQueue，它将您的currrent队列作为dispatch_queue_t返回。

斯威夫特3：

if let currentDispatch = OperationQueue.current?.underlyingQueue {
    print(currentDispatch)
}

- 适用于主队列！

Answer 2

随着dispatch_get_current_queue()的弃用，实际上无法知道您正在执行的队列。如果你仔细阅读GCD sources，你最终会看到这是因为“我正在执行什么队列？”这个问题可能有多个答案。（因为队列最终会定位其中一个全局队列等）。

如果要保证将来的块在特定队列上运行，那么唯一的方法是让API接受队列作为参数以及完成块。这使得调用者可以决定执行完成的位置。

如果仅仅知道调用者是否在主线程上就足够了，您可以使用+[NSThread isMainThread]查找。在通常情况下，在主GCD队列上执行的所有块都将在主线程上执行。（此规则的一个例外是，如果您的应用程序使用dispatch_main()代替主运行循环，则必须使用dispatch_get_specific和朋友来确定您正在主队列上执行 - 这是一个相对罕见的情况。）更常见的是，请注意，并非所有在主线程上执行的代码都通过GCD在主队列上执行; GCD从属于主线程runloop。对于你的具体情况，听起来似乎就足够了。

Answer 3

您可以选择"dispatch_get_current_queue()"，但iOS 6.1 SDK会使用这些免责声明定义此API：

“Recommended for debugging and logging purposes only:”

和

“This function is deprecated and will be removed in a future release.”。

Here's another related question with some alternatives您可以考虑是否需要具有面向未来的代码。

Answer 4

弃用dispatch_get_current_queue()时，您无法直接获取指向正在运行的队列的指针，但是可以通过调用{{{}来获取当前队列的标签 1}}这确实给你一些灵活性。

您可以随时通过比较标签来检查您是否在该特定队列中，因此在您的情况下，如果您不想强制它在主队列上，当您输入方法时，您可以使用以下内容flag：

dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL)

如果您在全局队列上运行，您将尊重与其关联的QOS类型的队列标签，该标签可以是以下之一：

let isOnMainQueue = (dispatch_queue_get_label(dispatch_get_main_queue()) == dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL))

然后您可以使用com.apple.root.user-interactive-qos //qos_class_t(rawValue: 33) com.apple.root.user-initiated-qos //qos_class_t(rawValue: 25) com.apple.root.default-qos //qos_class_t(rawValue: 21) com.apple.root.utility-qos //qos_class_t(rawValue: 17) com.apple.root.background-qos //qos_class_t(rawValue: 9)，它将返回您正在运行的同一个全局队列。

但我相信Apple特别不鼓励我们将逻辑限制在我们调用的队列中，因此最好将其用于完全调试目的。

Answer 5

基于 Oleg Barinov 答案

详细信息

Swift 5.1，Xcode 11.3.1

解决方案

import Foundation

// MARK: private functionality

extension DispatchQueue {

    private struct QueueReference { weak var queue: DispatchQueue? }

    private static let key: DispatchSpecificKey<QueueReference> = {
        let key = DispatchSpecificKey<QueueReference>()
        setupSystemQueuesDetection(key: key)
        return key
    }()

    private static func _registerDetection(of queues: [DispatchQueue], key: DispatchSpecificKey<QueueReference>) {
        queues.forEach { $0.setSpecific(key: key, value: QueueReference(queue: $0)) }
    }

    private static func setupSystemQueuesDetection(key: DispatchSpecificKey<QueueReference>) {
        let queues: [DispatchQueue] = [
                                        .main,
                                        .global(qos: .background),
                                        .global(qos: .default),
                                        .global(qos: .unspecified),
                                        .global(qos: .userInitiated),
                                        .global(qos: .userInteractive),
                                        .global(qos: .utility)
                                    ]
        _registerDetection(of: queues, key: key)
    }
}

// MARK: public functionality

extension DispatchQueue {
    static func registerDetection(of queue: DispatchQueue) {
        _registerDetection(of: [queue], key: key)
    }

    static var currentQueueLabel: String? { current?.label }
    static var current: DispatchQueue? { getSpecific(key: key)?.queue }
}

用法

检测系统队列

DispatchQueue.currentQueueLabel
DispatchQueue.current
DispatchQueue.global(qos: .default) == DispatchQueue.current
DispatchQueue.main === DispatchQueue.current

检测自定义队列

let queue = DispatchQueue(label: "queue-sample")
DispatchQueue.registerDetection(of: queue)
if DispatchQueue.current == queue { ... }

样本

不要忘记在此处粘贴解决方案代码。

func subTest(queue: DispatchQueue) {
    queue.async {
        print("--------------------------------------------------------")
        print("queue label: \(DispatchQueue.currentQueueLabel ?? "nil")")
        print("print DispatchQueue.current: \(String(describing: DispatchQueue.current))")
        print("print queue == DispatchQueue.current: \(queue == DispatchQueue.current)")
        print("print queue === DispatchQueue.current: \(queue === DispatchQueue.current)")
        print("DispatchQueue.main == DispatchQueue.current: \(DispatchQueue.main == DispatchQueue.current)\n")
    }
}

func test() {
    subTest(queue: DispatchQueue.main)
    sleep(1)
    subTest(queue: DispatchQueue.global(qos: .default))
    sleep(1)
    subTest(queue: DispatchQueue.global(qos: .utility))
    sleep(1)

    let queue = DispatchQueue(label: "queue-sample")
    DispatchQueue.registerDetection(of: queue)
    subTest(queue: queue)
    sleep(1)
}

test()
DispatchQueue.global(qos: .default).async {
    test()
}

结果

--------------------------------------------------------
queue label: com.apple.root.default-qos
print DispatchQueue.current: Optional(<OS_dispatch_queue_global: com.apple.root.default-qos[0x7fff89eb47c0] = { xref = -2147483648, ref = -2147483648, sref = 1, target = [0x0], width = 0xfff, state = 0x0060000000000000, in-barrier}>)
print queue == DispatchQueue.current: true
print queue === DispatchQueue.current: true
DispatchQueue.main == DispatchQueue.current: false

--------------------------------------------------------
queue label: com.apple.root.utility-qos
print DispatchQueue.current: Optional(<OS_dispatch_queue_global: com.apple.root.utility-qos[0x7fff89eb46c0] = { xref = -2147483648, ref = -2147483648, sref = 1, target = [0x0], width = 0xfff, state = 0x0060000000000000, in-barrier}>)
print queue == DispatchQueue.current: true
print queue === DispatchQueue.current: true
DispatchQueue.main == DispatchQueue.current: false

--------------------------------------------------------
queue label: queue-sample
print DispatchQueue.current: Optional(<OS_dispatch_queue_serial: queue-sample[0x600000275780] = { xref = 7, ref = 3, sref = 2, target = com.apple.root.default-qos.overcommit[0x7fff89eb4840], width = 0x1, state = 0x0060002500000b01, enqueued, max qos 5, draining on 0xb03, in-barrier}>)
print queue == DispatchQueue.current: true
print queue === DispatchQueue.current: true
DispatchQueue.main == DispatchQueue.current: false

--------------------------------------------------------
queue label: com.apple.main-thread
print DispatchQueue.current: Optional(<OS_dispatch_queue_main: com.apple.main-thread[0x7fff89eb43c0] = { xref = -2147483648, ref = -2147483648, sref = 1, target = com.apple.root.default-qos.overcommit[0x7fff89eb4840], width = 0x1, state = 0x001ffe9000000300, dirty, in-flight = 0, thread = 0x303 }>)
print queue == DispatchQueue.current: true
print queue === DispatchQueue.current: true
DispatchQueue.main == DispatchQueue.current: true

--------------------------------------------------------
queue label: com.apple.main-thread
print DispatchQueue.current: Optional(<OS_dispatch_queue_main: com.apple.main-thread[0x7fff89eb43c0] = { xref = -2147483648, ref = -2147483648, sref = 1, target = com.apple.root.default-qos.overcommit[0x7fff89eb4840], width = 0x1, state = 0x001ffe9000000300, dirty, in-flight = 0, thread = 0x303 }>)
print queue == DispatchQueue.current: true
print queue === DispatchQueue.current: true
DispatchQueue.main == DispatchQueue.current: true

--------------------------------------------------------
queue label: com.apple.root.default-qos
print DispatchQueue.current: Optional(<OS_dispatch_queue_global: com.apple.root.default-qos[0x7fff89eb47c0] = { xref = -2147483648, ref = -2147483648, sref = 1, target = [0x0], width = 0xfff, state = 0x0060000000000000, in-barrier}>)
print queue == DispatchQueue.current: true
print queue === DispatchQueue.current: true
DispatchQueue.main == DispatchQueue.current: false

--------------------------------------------------------
queue label: com.apple.root.utility-qos
print DispatchQueue.current: Optional(<OS_dispatch_queue_global: com.apple.root.utility-qos[0x7fff89eb46c0] = { xref = -2147483648, ref = -2147483648, sref = 1, target = [0x0], width = 0xfff, state = 0x0060000000000000, in-barrier}>)
print queue == DispatchQueue.current: true
print queue === DispatchQueue.current: true
DispatchQueue.main == DispatchQueue.current: false

--------------------------------------------------------
queue label: queue-sample
print DispatchQueue.current: Optional(<OS_dispatch_queue_serial: queue-sample[0x60000027a280] = { xref = 7, ref = 3, sref = 2, target = com.apple.root.default-qos.overcommit[0x7fff89eb4840], width = 0x1, state = 0x0060002500000b01, enqueued, max qos 5, draining on 0xb03, in-barrier}>)
print queue == DispatchQueue.current: true
print queue === DispatchQueue.current: true
DispatchQueue.main == DispatchQueue.current: false

Answer 6

实际上还有一种比较队列的方法。

设置队列时，请确保添加标签。出于我的目的，我有一个共享队列，用于访问数据库以防止数据库锁定。在我的DB.m文件中，我已经定义了共享队列函数，如：

const char *kTransactionQueueLabel = "DB_TRANSACTION_DISPATCH_QUEUE";

+ (dispatch_queue_t)sharedDBTransactionQueue {
    static dispatch_queue_t sharedDBQueue = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedDBQueue = dispatch_queue_create(kTransactionQueueLabel, DISPATCH_QUEUE_SERIAL);
    });

    return sharedDBQueue;
}

共享db事务队列在文件中本地使用，以将所有执行分派给数据库。但是，此处还有一个公共访问器，允许将整个事务分派到数据库。所以在内部，如果从事务队列中调用DB访问方法，我们需要在不同的队列内部调度（所有同步调度）。所以在内部，我总是通过使用下面的getter来调度正确的队列。

/**
 * @description Decide which queue to use - if we are already in a transaction, use the internal access queue, otherwise use the shared transaction queue.
 */
- (dispatch_queue_t)getProperQueueForExecution {
    const char *currentLabel = dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL);
    dispatch_queue_t sharedAccessQueue = [DB sharedDBTransactionQueue];
    if (strcmp(currentLabel, kTransactionQueueLabel) == 0) {
        sharedAccessQueue = [DB sharedInternalDBAccessQueue];
    }

    return sharedAccessQueue;
}

希望这会有所帮助。很抱歉这个很长的例子。它的要点是你可以使用

const char *currentLabel = dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL);

获取当前队列的标签并与定义的标签进行比较。

Answer 7

作为此NSOBject方法的替代方法，performSelector:withObject:afterDelay:会在当前线程的运行循环中调度该调用。根据文件：

此方法设置一个计时器来执行aSelector消息当前线程的运行循环。

显然我建议使用这个延迟为零，根据文档再次说明：

指定延迟0并不一定会导致选择器马上执行。选择器仍然在线程上排队运行循环并尽快执行。

不幸的是，它只需要一个参数，因此如果您的方法需要更多或更少，则可能需要一些解决方法。

我注意到的另一件事是这种方法不适用于协议，而仅适用于实现。这是因为此方法位于NSObject类别，而不是NSObject界面（请参阅下面的PS）。这可以通过强制转换为id来轻松修复。

PS：存在两个不同的NSObject，一个协议和一个实现。请注意NSObject声明：

@interface NSObject <NSObject> { ... }

这可能看起来很奇怪，但是一个被宣布（在@interface之后），而另一个是先前声明的协议（在<和>之间）。当声明扩展NSObject的协议（即，@protocol Foo <NSObject>）时，协议继承了后者的方法，但不是前者。最终，协议由一些继承自NSObject实现的类实现，因此从NSObject实现继承的所有实例仍然成立。但是我离开了主题。

Answer 8

如果您只对当前的QOS感兴趣，请检查Giuseppe的值。

Answer 9

要获取当前队列的标签并使用，将其与定义的标签进行比较。

let queueName = dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL)

Answer 10

基于SQLite.swift的来源。
如果要检查自己是否在特殊的发送队列中：

class Worker {
    private static let queueKey = DispatchSpecificKey<Int>()
    private lazy var queueContext = unsafeBitCast(self, to: Int.self)
    private lazy var queue: DispatchQueue = {
        let value = DispatchQueue(label: "com.example.App.Worker")
        value.setSpecific(key: Worker.queueKey, value: queueContext)
        return value
    }()

    func test(x: Int) -> Int {
        return dispatchSync {
            return x > 2 ? test(x: x - 1) * x : x
        }
    }

    private func dispatchSync<T>(_ block: () throws -> T) rethrows -> T {
        if DispatchQueue.getSpecific(key: Worker.queueKey) != queueContext {
            return try queue.sync(execute: block)
        }
        return try block()
    }
}

let worker = Worker()
worker.test(x: 5)

获取当前的调度队列？

10 个答案:

详细信息

解决方案

用法

样本

结果