Compartir datos entre el hilo maestro y el hilo esclavo en un entorno controlado por interrupciones en C

Tengo los siguientes

f1() { while(1) { call f(2) if hardware interrupt pin goes high } } f2() { if( th() not started ) { start thread th() } else { return thread th() status } } th() { time-consuming operation } 

En este momento, uso lo siguiente para iniciar una estructura en f2 ():

 static struct SharedData shared; if( shared == NULL) { initialize shared } 

Luego paso un puntero para compartir al hilo. El hilo luego se actualiza periódicamente. f2 () sabrá entonces si th () se ha iniciado basándose en elementos compartidos y verificará el estado de th () leyendo desde compartido .

Supongamos que uno de los elementos compartidos es un mutex para proporcionar seguridad de subprocesos. ¿Es esta una buena solución? ¿Hay una forma más elegante de hacer esto? He probado el código y funciona. Sólo necesito un consejo experto aquí.

Gracias,

Suponiendo que f2() use la misma exclusión mutua en la estructura shared para bloquear antes de leer los datos que utiliza el hilo para modificar los datos, no veo ningún problema.

Si tiene más de un hilo llamando a f2() , puede usar un locking de lectura y escritura para leer y escribir el estado del hilo de th . El mutex podría seguir utilizándose para serializar la verificación de la creación de hilos. También puede usar un pthread_rwlock_wrlock() para serializar th creación, pero el código es menos claro.

Usando un mutex para serializar th creación en f2() :

 pthread_rwlock_rdlock(&shared.rwlock); result = shared.th_status; if (! shared.th_created) { pthread_mutex_lock(&shared.mutex); if (! shared.th_created) { pthread_create(...); shrared.th_created = 1; } pthread_mutex_unlock(&shared_mutex); } pthread_rwlock_unlock(&shared.rwlock); return result; 

Usando el locking de lectura-escritura para serializar th creación en f2() :

 pthread_rwlock_rdlock(&shared.rwlock); result = shared.th_status; if (! shared.th_created) { pthread_rwlock_unlock(&shared.rwlock); pthread_rwlock_wrlock(&shared.rwlock); if (! shared.th_created) { pthread_create(...); shrared.th_created = 1; } } pthread_rwlock_unlock(&shared.rwlock); return result;