En el entorno Linux, ¿cómo utilizar varios temporizadores en subprocesos múltiples? ¿Se pueden utilizar temporizadores POSIX y cómo utilizarlos?

Lo resolví personalmente, aquí hay una implementación:

#include lt; stdlib.hgt

#include lt

#include lt;stdio.hgt;

#include lt;signal.hgt;

#include lt;string.hgt;

# incluir lt;pthread.hgt;

#include lt;time.hgt;

#if 1

pthread_attr_t attr;

timer_t hard_timer, software_timer;

struct sigevent hard_evp, software_evp;

static void watchdog_hard_timeout(union sigval v)

{

time_t t;

char p[32];

timer_t *q;

struct itimerspec ts

int ret; p > time(amp;t);

strftime(p, sizeof(p), "T", localtime(amp;t));

printf("tiempo de espera estricto del perro guardián ! \n");

printf("s hilo d, val = u, señal capturada.\n", p, (unsigned int)pthread_self(), v.sival_int);

q = (timer_t *)(v.sival_ptr);

printf("hard timer_t: d add: p, q: p!\n", (int)hard_timer, amp; hard_timer, q

ts.it_interval.tv_sec = 0;

ts.it_interval.tv_nsec = 0

ts.it_value.tv_sec = 6; p >

ts.it_value.tv_nsec = 0;

ret = timer_settime(*q, CLOCK_REALTIME, amp; ts, NULL

if (ret != 0) {

printf("settime err(d)!\n",

}

}

static void watchdog_software_timeout); ( unión sigval v)

{

time_t t;

char p[32];

timer_t *q;

estructura de temporizadores

pec ts;

int ret;

tiempo(amp; t

strftime(p, sizeof(p), "T", hora local(amp); ;t));

printf("¡tiempo de espera del software de vigilancia!\n");

printf("s hilo d, val = u, señal capturada.\n", p , (unsigned int)pthread_self(), v.sival_int);

q = (timer_t *)(v.sival_ptr);

printf("hard timer_t: d add: p , q: p!\n", (int)hard_timer, amp; hard_timer, q);

ts.it_interval.tv_sec = 0;

ts.it_interval.tv_nsec = 0 ;

ts.it_value.tv_sec = 10;

ts.it_value.tv_nsec = 0;

ret = timer_settime(*q, CLOCK_REALTIME, amp; ts , NULL);

if (ret != 0) {

printf("settime err(d)!\n", ret);

}

}

vacío estático dcmi_sol_pthread_attr_destroy(pthread_attr_t *attr)

{

pthread_attr_destroy(attr);

}

static int dcmi_sol_pthread_attr_init(pthread_attr_t *attr)

{

int ret;

if ((ret = pthread_attr_init(attr) != 0)) {

goto err;

}

if ((ret = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED)) != 0) {

dcmi_sol_pthread_attr_destroy(attr);

goto err;

}

/* Establece el tamaño de pila del hilo y usa el valor predeterminado del sistema valor si falla* /

pthread_attr_setstacksize(attr, 128 * 1024);

devuelve 0

err:

printf( "Error al establecer el atributo ptread (ret: d)!\n", ret

return

}

;

int main(void)

{

struct itimerspec ts;

int ret;

ret = dcmi_sol_pthread_attr_init(amp; attr);

if (ret != 0) {

printf("¡los atributos de inicio de pthread fallan(d)!\n",

exit(-); 1);

}

memset(amp; hard_evp, 0, sizeof(struct sigevent));

hard_evp.sigev_value.sival_ptr = amp;

hard_evp.sigev_notify = SIGEV_THREAD;

hard_evp.sigev_notify_function = watchdog_hard_timeout

hard_evp.sigev_notify_attributes = NULL //amp; p> memset(amp; software_evp, 0, sizeof(struct sigevent));

software_evp.sigev_value.sival_ptr = amp; software_timer;

software_evp.sigev_notify = SIGEV_THREAD;

software_evp.sigev_notify_function = watchdog_software_timeout;

software_evp.sigev_notify_attributes = NULL; //amp;attr;

ret = timer_create(CLOCK_REALTIME, amp;hard_evp, amp;hard_timer) ;

if(ret != 0) {

perror("hard timer_create fall!");

exit(-1);

}

ret = timer_create(CLOCK_REALTIME, software_evp, software_timer);

if (ret != 0) {

timer_delete( hard_timer); /p>

perror("¡el software timer_create falla!");

exit(-1);

}

ts. 0;

ts.it_interval.tv_nsec = 0;

ts.it_value.tv_se;

c = 6;

ts.it_value.tv_nsec = 0;

ret = timer_settime(hard_timer, CLOCK_REALTIME, amp; ts, NULL

if( ret != 0) {

perror("hard timer_settime fall!");

timer_delete(hard_timer);

timer_delete(software_timer);

salir(-1);

}

ts.it_value.tv_sec = 10;

ret = timer_settime(software_timer, CLOCK_REALTIME, amp; ts, NULL);

if(ret != 0) {

perror("hard timer_settime fall!");

timer_delete(hard_timer);

timer_delete(software_timer);

salir(-1

}

mientras(1) {