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) { p>
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) {
printf("¡principal listo para dormir!\n");
dormir(15
printf("¡principal para dormir terminado!\n"); > }
devuelve 0;
}
#endif