块和 libdispatch 在 Linux 上可用吗？

Question

我很想尝试 Grand Central Dispatch，但我必须在 Ubuntu 工作站上进行开发。 libdispatch 以及 c/obj-c 等的块扩展在 Linux 上可用吗？如果是这样，我如何获得它们？

Answer 1

您可能需要使用 LLVM Clang（在 Ubuntu 上可用） 编译器此时获取块（我不认为这在 gcc 中可用，但我还没有跟上 gcc，所以我可能是错的。）

正在努力移植 libdispatch（开源 libdispatch 的主页） 到 Linux。到目前为止，大部分工作似乎都在 Debian 上，但也有一些在其他发行版上。请参阅这些讨论主题：

• linux + libdispatch + clang + 块
• libdispatch移植状态更新
• 适用于 Debian 的 Grand Central Dispatch（已存档链接）

Answer 2

我已经做了一些工作，让 OS X Mountain Lion 版本的 libdispatch 在 Linux 上运行；结果在 Github 上：http://nickhutchinson.me/libdispatch/。

Answer 3

使用 clang-3.4。

• sudo apt-get install libdispatch-dev
• sudo apt-get install libblocks-runtime-dev
• 使用 -fblocks 编译
• 使用 -lBlocksRuntime -ldispatch 链接

Answer 4

使用 C++ lambda，而不是使用块。他们使用 C++ 玩得更好，并且隐藏的魔法更少。

我这样做：

/// Dispatch a function object to a queue.
template<class F>
static void dispatch_async_function(dispatch_queue_t queue, F f) {
    struct context_t {
        using function_type = F;

        context_t(function_type&& f) noexcept
        : _f(std::move(f))
        {}

        static void execute(void* p) noexcept {
            auto context = reinterpret_cast<context_t*>(p);
            if (context) {
                try {
                    context->_f();
                }
                catch(...) {
                    // error processing here
                }
                delete context;
            }
        }

    private:
        function_type _f;
    };

    dispatch_async_f(queue, new context_t<F>(std::move(f)), &context_t<F>::execute);
}

如果您需要确保在调用发生之前存在某些共享资源（例如通过共享指针保持活动状态的对象上的回调）：

/// Dispatch a function object to a queue. Only execute the function if the tie
/// locks successfully.
template<class F>
static void dispatch_async_tied_function(dispatch_queue_t queue, std::weak_ptr<void> tie, F f) {
    struct context_t {
        using function_type = F;

        context_t(function_type&& f) noexcept
        : _f(std::move(f))
        {}

        static void execute(void* p) noexcept {
            auto context = reinterpret_cast<context_t*>(p);
            auto lock = _tie.lock();
            if (context && tie) {
                try {
                    context->_f();
                }
                catch(...) {
                    // error processing here
                }
                delete context;
            }
        }

    private:
        function_type _f;
        std::weak_ptr<void> _tie;
    };

    dispatch_async_f(queue, new context_t<F>(std::move(f)), &context_t<F>::execute);
}

像这样调用它们

dispatch_function(queue, []() { something(); });

或...

dispatch_tied_function(_myQueue, shared_from_this(), [this]() { somethingOnThis(); });