Se agrega un ejemplo de Glib::Thread.

diff --git a/tests/gtkmm/threads/threads.cc b/tests/gtkmm/threads/threads.cc
new file mode 100644 (file)
index 0000000..fc49036
--- /dev/null
+++ b/tests/gtkmm/threads/threads.cc
@@ -0,0 +1,71 @@
+/*
+ * Ejemplo de threads con la glibmm.
+ *
+ * Para compilar:
+ * g++ -Wall `pkg-config --cflags --libs glibmm-2.0 gthread-2.0` -o threads threads.cc
+ *
+ */
+
+#include <cstdlib>
+#include <glibmm/thread.h>
+#include <iostream>
+
+void ejecuta_animal(const char* yo)
+{
+       int cuento = 500 + rand()%500;
+
+       std::cout << yo << ": voy contar hasta " << cuento << std::endl;
+       // Yieldea para que primero imprima todas las "cabeceras".
+       Glib::Thread::yield();
+
+       for (int i = 0; i <= cuento; i++) {
+               // Si es multiplo de 100, imprimo.
+               if (!(i % 100)) {
+                       std::cout << "  " << yo << ": voy por " << i << " de "
+                               << cuento << std::endl;
+               }
+               // Deja que se schedulee otro thread...
+               // XXX - La doc recomiendo no usar esta funcion, pero la pongo
+               // pa' probar nomas :)
+               Glib::Thread::yield();
+       }
+}
+
+int main(int argc, char *argv[])
+{
+       // Pone semilla para random.
+       srand(time(0));
+       // Inicializa "sistema de threads".
+       Glib::thread_init();
+       // Crea un thread., por defecto no toma argumentos el thread, por lo
+       // que con SigC::bind() le "agrego" un argumento (de tipo const char*)
+       // adicional a la llamada.
+       Glib::Thread* thread1 = Glib::Thread::create(
+                       SigC::bind<const char*>(
+                               SigC::slot(&ejecuta_animal),
+                               "GNU"),
+                       0, // Stack por defecto.
+                       true, // Es 'joinable'.
+                       true, // Se 'schedulea' a nivel de proceso (en linux siempre es asi)
+                       Glib::THREAD_PRIORITY_LOW);
+       Glib::Thread* thread2 = Glib::Thread::create(
+                       SigC::bind<const char*>(
+                               SigC::slot(&ejecuta_animal),
+                               "Vaca"),
+                       0, // Stack por defecto.
+                       true, // Es 'joinable'.
+                       true, // Se 'schedulea' a nivel de proceso (en linux siempre es asi)
+                       Glib::THREAD_PRIORITY_LOW);
+       // Se crea con todo por default (incluso la prioridad).
+       Glib::Thread* thread3 = Glib::Thread::create(
+                       SigC::bind<const char*>(
+                               SigC::slot(&ejecuta_animal),
+                               "Conejo"),
+                       true);
+       // Espera a que terminen todods.
+       thread1->join();
+       thread2->join();
+       thread3->join();
+       return 0;
+}
+