pthread_cond_timpedwait ()

Ce code ne dort pas, il vérifie une condition pendant un moment. Comme vous n'êtes probablement pas probablement réglé, OK, cela revient simplement immédiatement.

Si vous n'êtes pas disposé à synchroniser les threads autour d'un signal, pthread_cond _wait n'est pas ce dont vous avez besoin. Vérifiez ici Comment fonctionne les variables de la condition.

Si vous souhaitez dormir avec des secondes de précision, utilisez Dormez

Si vous souhaitez dormir avec des microsecondes Precision Utilisez Sélectionnez avec Timevals.

Considérant que vous utilisez TimesPec, et votre objectif n'est pas de se synchroniser, mais d'attendre, je vous suggérerais de nanosleep.

#include <time.h>

.
.
.

  struct timespec remain;
  remain.tv_sec = 5;
  remain.tv_nsec = timeInMs * 1000;

  do {
    if ( nanosleep( &remain, &remain ) == 0 || errno != EINTR ) {
      break;
    }
  } while ( 1 );

.
.
.

Utilisation de n'importe quelle variante de sommeil, le comportement n'est pas garanti. Tous les fils peuvent également dormir car le noyau n'est pas au courant des différents threads.

Une solution plus sûre et plus propre à utiliser est pthread_cond_timpedwait code>. Vous avez utilisé l'API de manière incorrecte. Voici un meilleur exemple: P>

pthread_mutex_t fakeMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t fakeCond = PTHREAD_COND_INITIALIZER;

void mywait(int timeInMs)
{
    struct timespec timeToWait;
    struct timeval now;
    int rt;

    gettimeofday(&now,NULL);


    timeToWait.tv_sec = now.tv_sec+5;
    timeToWait.tv_nsec = (now.tv_usec+1000UL*timeInMs)*1000UL;

    pthread_mutex_lock(&fakeMutex);
    rt = pthread_cond_timedwait(&fakeCond, &fakeMutex, &timeToWait);
    pthread_mutex_unlock(&fakeMutex);
    printf("\nDone\n");
}

void* fun(void* arg)
{
    printf("\nIn thread\n");
    mywait(1000);
}

int main()
{
    pthread_t thread;
    void *ret;

    pthread_create(&thread, NULL, fun, NULL);
    pthread_join(thread,&ret);
}

Le pthread_cond_timpedwait fonctionne un absolu temps, pas une heure relative. Il faut le temps que vous voulez arrêter d'attendre, pas combien de temps vous voulez attendre.