linux - 块和 libdispatch 在 Linux 上可用吗？

Question

我很想尝试大型中央调度，但我需要开发的只是一个 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++ lambdas。他们用 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(); });