¿Las funciones para dormir duermen todas las secuencias o solo la que lo llama?

Question

Estoy programando con pthread en linux (Centos)? Quiero enhebrar un poco de tiempo para esperar algo. Estoy tratando de usar sleep(), nanosleep(), o usleep() o tal vez algo puede hacer eso. Quiero preguntar eso: ¿las funciones para dormir duermen todos los hilos o solo quien lo llama? Cualquier consejo o referencia sería apreciado.

void *start_routine() { 
    /* I just call sleep functions here */ 
    sleep (1); /* sleep all threads or just the one who call it? 
        what about nanosleep(), usleep(), actually I 
        want the threads who call sleep function can 
        sleep with micro-seconds or mili-seconds. 
       */ 
    ... 
} 

int main (int argc, char **argv) { 
    /* I just create threads here */ 
    pthread_create (... ...); 
    ... 
    return 0; 
} 

---

Mi programa de pruebas:

#define _GNU_SOURCE 
#include <pthread.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <sched.h> 
#include <unistd.h> 

void *start_routine (void *j) { 

    unsigned long sum; 
    int i; 
    int jj; 
    jj = (int)j; 
    do { 
     sum = 1; 
     for (i=0; i<10000000; i++) { 
      sum = sum * (sum+i); 
     } 
     if (jj == 0) { 
      printf ("\033[22;33m[jj%d.%ld]\t", jj, sum); 
      sleep(1);   
     } 
     else { 
      printf ("\033[22;34m[jj%d.%ld]\t", jj, sum); 
     } 

    }while (1); 

    pthread_exit((void *)0); 
} 
int main(int argc, char *argv[]) 
{ 
    cpu_set_t cpuset; 
    pthread_t thread[2]; 
    int i; 
    i = 0; 
    CPU_ZERO(&cpuset); 
    CPU_SET(i, &cpuset); 

    pthread_create (&thread[0], NULL, start_routine, (void *)i); 
    pthread_setaffinity_np(thread[0], sizeof(cpu_set_t), &cpuset); 
    i = 1; 
    CPU_ZERO(&cpuset); 
    CPU_SET(i, &cpuset); 
    pthread_create (&thread[1], NULL, start_routine, (void *)i); 
    pthread_setaffinity_np(thread[1], sizeof(cpu_set_t), &cpuset); 
    pthread_exit (NULL); 
} 

Answer 1

The standard lo explica:

El sueño() la función se produce el subproceso de llamada para ser suspendido de la ejecución hasta que ....

El linux uno es tan clara :

sleep() hace que el hilo de llamada duerma hasta ...

Sin embargo, hay algunas referencias erróneas que mantienen lo contrario. linux.die.net solía indicar sleep hace que espere el proceso.

Answer 2

Sólo el hilo que llama a la función.