Threads (reloaded)

[Minos]

 Hola, estoy buscando informacion sobre los threads, algun tutorial en español y librerias que te lo permitan implementar multiplataforma.

Por google he encontrado bastantes pero la mayoria estan basados en java (y visual basic en msdn) y prefiero c++ o c# en su defecto.Buscando threads c# y threads c++ no he encontrado algo claro :(
Si conoceis alguno os lo agradeceria.

Sobre las librerias multiplataforma me estoy haciendo un lio. He encontrado OpenThreads pero no esta en version estable y hace tiempo que no se actualiza (2003).
Tambien he visto por ahi algo llamado POSIX threads (o pthreads) pero no se si son multiplatarfoma o que son.

Tambien he buscado por el historial de este foro y tampoco.

Siento si la pregunta es demasiado estupida o no se buscar pero es que me quiero iniciar en el tema de threads y estoy dando palos de ciego.

saludos

[Sacrifai]

 http://www.yolinux.com/TUTORIALS/GDK_Threads.html

¿Te podría servir esta lib?

[senior wapo]

 Pthreads es una libreria multiplataforma pero para windows es algo pesada para mi gusto, más que nada porque los threads los puedes hacer multiplataforma con un simple fichero de cabecera a base de macros (C/C++). La razón es que el API de windows y el de pthreads ofrecen los mismos servicios si solo necesitas lanzar hilos y semáforos simples.

Te pego unas macros que me hice hará como 8 o 9 años (lo use un par de veces solo), vaya usted a saber si ahora compila o no ;)

Código [Seleccionar] Expand


#ifndef __THREADS_H__

#define __THREADS_H__

#define _REENTRANT

#ifdef WIN32

/* WIN32 VERSION */

#include <windows.h>
#include <process.h>

#define THREADOBJ  HANDLE

#define INVALID_THREAD ((HANDLE)-1)

#define thread_SysInit() (1)
#define thread_SysExit() (1)

#define thread_fast_create(obj,proc,stack,value) \
(*(obj)=(THREADOBJ)_beginthread((void (*)(void *))(proc),(stack),(void *)(value)), *obj)

#define thread_create(obj,proc,stack,value) \
(*(obj)=(THREADOBJ)_beginthread((void (*)(void *))(proc),(stack),(void *)(value)), *obj)

#if 0
typedef struct {
   void *value;
   void (* func)(void *);
   } __static_spawn_struct;

static void __static_spawn_thread2_(__static_spawn_struct **obj)
{
__static_spawn_struct *vp;
void (* func)(void *);
void *value;

   vp=*obj;
   func=vp->func;
   value=vp->value;
   *((THREADOBJ *)obj)=GetCurrentThreadId();
   return func(value);
}

static int __static_spawn_thread_(unsigned int stack,__static_spawn_struct **obj,
   void (* proc)(void *),void *value)
{
__static_spawn_struct vp;   /* on the stack, so it is reentrant */
int rt;

   vp.func  = proc;
   vp.value = value;
   *obj=&vp;
   rt=_beginthread((void (*)(void *))__static_spawn_thread2_,stack,obj );
   return rt;
}

#define thread_create(obj,proc,stack,value) \
__static_spawn_thread_(stack,(__static_spawn_struct **)obj,(void (*)(void *))proc,(void *)value)
#endif

#if 0
static void __static_thread_kill_function(HANDLE a)
{
   TerminateThread(a,0xFFFFFFFF);
   CloseHandle(a);    /* this blocks the whole program! */
}
#define thread_kill(a) __static_thread_kill_function(a)
#else
#define thread_kill(a) TerminateThread(a,0xFFFFFFFF)
#endif

#define thread_exit() _endthread()
#define thread_current()  GetCurrentThreadId()
#define thread_equal(a,b)  ((a)==(b))
#define thread_error(a)  (((unsigned int)(a))==(-1))
#define thread_sleep(a) SuspendThread(a)
#define thread_awake(a) ResumeThread(a)



#define MUTEXOBJ  CRITICAL_SECTION

#define MUTEX_ERROR    (-1)



#define thread_InitMutex(a)   InitializeCriticalSection((a))

#define thread_KillMutex(a)   DeleteCriticalSection((a))

#define thread_EnterMutex(a)  EnterCriticalSection((a))

#define thread_ExitMutex(a)   LeaveCriticalSection((a))



#else

/* LINUX VERSION */

#include <pthread.h>

#define thread_SysInit()   __pthread_initialize()
#define thread_SysExit()   (1)

#define THREADOBJ pthread_t
#define INVALID_THREAD (-1)

#define thread_fast_create(obj,proc,stack,value) \
pthread_create(obj,NULL,(void *(*)(void *))(proc),(void *)(value))

#define thread_create(obj,proc,stack,value) \
pthread_create(obj,NULL,(void *(*)(void *))(proc),(void *)(value))

#define thread_exit()     pthread_exit(0)
#define thread_kill(a)    pthread_cancel((a))
#define thread_current()  pthread_self()
#define thread_equal(a,b) pthread_equal((a),(b))
#define thread_error(a) ((a)!=0)
#define thread_sleep(a)  (1)
#define thread_awake(a)  (1)


#define MUTEXOBJ  pthread_mutex_t
#define MUTEX_ERROR  (-1)

#define thread_InitMutex(a)   pthread_mutex_init((a),NULL)
#define thread_KillMutex(a)   pthread_mutex_destroy((a))
#define thread_EnterMutex(a)  pthread_mutex_lock((a))
#define thread_ExitMutex(a)   pthread_mutex_unlock((a))

#endif


/* End of #ifndef __THREADS_H__ */

#endif


Solo tienes que incluirlo en windows y no dependes de ninguna libreria. Bajo linux además necesitaras linkar con pthreads.

EDIT: Ahora que lo releo, hoy en dia podría ser una implementación más limpia. Está como está por limitaciones de las librerías/compiladores de entonces, o incompatibilidades raras, ya ni me acuerdo por qué era.

[Minos]

 Sacrifai no me termina por convencer esa libreria, en la documentacion me lo mezcla con gtk y me hago un lio (no se nada ni de threads ni de gtk), buscaba algo sencillito. De todos modos muchas gracias.
senior wapo muchas gracias por el archivo pero he estado intentando entender que hacer para crear threads ( xD ) y no se me da bien. Creo que quizas lo mejor seria que buscase una API sencillita de threads y que valla probando con ellos para familiarizarme por que segun parece no los he asimilado. Pero te agradezco mucho la voluntad.

He seguido buscando y he encontrado SDL_threads que parece que es sencillo y tienen tutoriales faciles de asimilar
SDL_Threads Documentation
Tutorial simple

Siguiendo por los nodos de la amada internet me he encontrado un FAQ sobre Threads y un grupo dedicado a ellos (thread education ...

Para .NET sobre c# http://www.c-sharpcorner.com/Code/2002/Apr...g.ThreadMT2.asp
Y en la msdn del framework System.Threading

Pongo todo esto mas que nada por si alguien en un futuro se ve en las mismas que yo.
Por mi parte creo que tirare un poco de SDL_Threads, o mejor .NET para hacer pruebas y ver que es eso de un mutex, etc


EDITO: En algo llamado Framework 2.0 Samples de la pagina del Framework de .NET vienen muchso ejemplos de threads