Question

我注意到它们在创建时不会返回指针，而是实际的对象。所以为了得到一个指针，我试图像这样声明：

dispatch_queue_t* queue;
*queue = dispatch_queue_create("double_buffer_protection_queue", DISPATCH_QUEUE_SERIAL);

我的C ++程序员说应该可以工作，但是它会出现BAD_ACCESS错误，所以我猜我正在以错误的方式接近它。

如果我想要一个可以被程序中的任何对象访问的串行队列，我该怎么做？我上面展示的代码意味着要进入AppDelegate类。

Answer 1

来自GCD Reference：typedef struct dispatch_queue_s *dispatch_queue_t;

也许我正在咆哮错误的树，但我的直觉会告诉我一个更惯用的解决方案可能是在类方法中使用dispatch_once函数来产生一个多个类实例可以发送工作的队列（它不是C ++但是你得到了基本的想法）：

+ (dispatch_queue_t)sharedQueue
{
    static dispatch_once_t pred;
    static dispatch_queue_t sharedDispatchQueue;

    dispatch_once(&pred, ^{
        sharedDispatchQueue = dispatch_queue_create("theSharedQueue", NULL);
    });

    return sharedDispatchQueue;
}

dispatch_once确保在整个运行时期间只创建一次队列，因此您可以根据需要随时安全，廉价地调用[YourClass sharedQueue]。

然而，我的直觉也告诉我，在类/对象之间共享队列的味道有点不好。如果您只想要一个应用程序范围的队列来提交其他作业，那么全局队列是否足够？如果你想对大量的对象做一些密集的工作，我本能地为它们设置一个单独的队列。也许有一种更优雅的方式来做你想做的事情？

Answer 2

在Grand Central Dispatch中，使用实际物体是正确的方法。例如，

class Manager
{
    Manager()
    {
        m_queue = dispatch_queue_create("double_buffer_protection_queue", DISPATCH_QUEUE_SERIAL);

        m_worker = new Worker(m_queue);
    }

    ~Manager()
    {
        dispatch_release(m_queue);
        delete m_worker;
    }

    dispatch_queue_t m_queue;
    Worker *m_worker;
}

然后队列的另一个所有者必须像Objective-C对象一样保留并释放它。

class Worker
{
    Worker(dispatch_queue_t queue)
    // Worker(dispatch_queue_t &queue) /* reference might be ok. */
    {
        m_queue = queue;
        dispatch_retain(m_queue);
    }

    ~Worker()
    {
        dispatch_release(m_queue);
    }

    dispatch_queue_t m_queue;
}

如何在类之间共享串行调度队列？

2 个答案: