Me gustaría probar el despacho de grand central, pero todo lo que tengo que desarrollar es una estación de trabajo Ubuntu. ¿Libdispatch y la extensión de bloques a c/obj-c, etc. están disponibles en Linux? Si es así, ¿cómo los obtengo?¿Hay bloques y libdispatch disponibles en Linux?
Puede que necesite utilizar el compilador LLVM Clang (available on Ubuntu) para obtener bloques en este momento (no creo que esto esté disponible en gcc todavía, pero no he estado al día con gcc, por lo que podría estar equivocado).
Hay esfuerzos en curso para el puerto libdispatch (home for the open source libdispatch) para Linux. La mayor parte del esfuerzo parece estar en Debian hasta ahora, pero también en otras distribuciones. Ver estas líneas de discusión:
que he hecho algún trabajo para obtener la versión OS X Mountain Lion de libdispatch trabajar en Linux; el resultado está arriba en Github: http://nickhutchinson.me/libdispatch/.
En lugar de usar bloques, use C++ lambdas. Juegan mejor con C++ y hay menos magia escondida.
lo hago de esta manera:
/// 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);
}
Y si es necesario asegurarse de que existe algún recurso compartido antes de la llamada tiene lugar (como una devolución de llamada en un objeto que se mantiene vivo gracias a un puntero compartido) :
/// 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);
}
los llaman como esto
dispatch_function(queue, []() { something(); });
o ...
dispatch_tied_function(_myQueue, shared_from_this(), [this]() { somethingOnThis(); });
Utilice clang-3.4.
Gracias ! Muchas búsquedas de Google no me dieron más que confusión. – mummey
¡De nada! Puede ser sorprendentemente difícil encontrar cosas como esta con Google a veces, particularmente en un tema que no es familiar. –
Mientras estés bien usando clang, estoy [usando gcd bastante feliz] (http://chris.mowforth.com/installing-grand-central-dispatch-on-linux) en ubuntu natty. –