Existe uma função de sono alternativa em C a milissegundos?

Eu tenho algum código fonte que foi compilado no Windows. Estou convertendo para rodar no Red Hat Linux.

O código fonte incluiu o <windows.h>arquivo de cabeçalho e o programador usou a Sleep()função para aguardar um período de milissegundos. Isso não vai funcionar no Linux.

No entanto, eu posso usar a sleep(seconds)função, mas isso usa inteiro em segundos. Não quero converter milissegundos em segundos. Existe uma função de suspensão alternativa que eu possa usar com a compilação do gcc no Linux?

Sim - padrões POSIX mais antigos definidos usleep(), portanto, isso está disponível no Linux:

   int usleep(useconds_t usec);

DESCRIÇÃO

A função usleep () suspende a execução do encadeamento de chamada por (pelo menos) microssegundos de usec. O sono pode ser prolongado levemente por qualquer atividade do sistema ou pelo tempo gasto no processamento da chamada ou pela granularidade dos cronômetros do sistema.

usleep()leva microssegundos , então você terá que multiplicar a entrada por 1000 para dormir em milissegundos.

usleep()foi descontinuado e removido do POSIX; para novo código, nanosleep()é preferido:

   #include <time.h>

   int nanosleep(const struct timespec *req, struct timespec *rem);

DESCRIÇÃO

nanosleep()suspende a execução do encadeamento de chamada até que pelo menos o tempo especificado *reqtenha decorrido ou a entrega de um sinal que dispara a chamada de um manipulador no encadeamento de chamada ou que encerre o processo.

A estrutura timespec é usada para especificar intervalos de tempo com precisão de nanossegundos. É definido da seguinte forma:

       struct timespec {
           time_t tv_sec;        /* seconds */
           long   tv_nsec;       /* nanoseconds */
       };

Um exemplo de msleep()função implementada usando nanosleep(), continuando o sono, se for interrompido por um sinal:

#include <time.h>
#include <errno.h>    

/* msleep(): Sleep for the requested number of milliseconds. */
int msleep(long msec)
{
    struct timespec ts;
    int res;

    if (msec < 0)
    {
        errno = EINVAL;
        return -1;
    }

    ts.tv_sec = msec / 1000;
    ts.tv_nsec = (msec % 1000) * 1000000;

    do {
        res = nanosleep(&ts, &ts);
    } while (res && errno == EINTR);

    return res;
}

Você pode usar esta função de plataforma cruzada:

#ifdef WIN32
#include <windows.h>
#elif _POSIX_C_SOURCE >= 199309L
#include <time.h>   // for nanosleep
#else
#include <unistd.h> // for usleep
#endif

void sleep_ms(int milliseconds) // cross-platform sleep function
{
#ifdef WIN32
    Sleep(milliseconds);
#elif _POSIX_C_SOURCE >= 199309L
    struct timespec ts;
    ts.tv_sec = milliseconds / 1000;
    ts.tv_nsec = (milliseconds % 1000) * 1000000;
    nanosleep(&ts, NULL);
#else
    usleep(milliseconds * 1000);
#endif
}

Como alternativa usleep(), que não está definida no POSIX 2008 (embora tenha sido definida até o POSIX 2004 e esteja evidentemente disponível no Linux e outras plataformas com histórico de conformidade com o POSIX), o padrão POSIX 2008 define nanosleep():

nanosleep - sono de alta resolução

#include <time.h>
int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);

A nanosleep()função deve fazer com que o encadeamento atual seja suspenso da execução até que o intervalo de tempo especificado pelo rqtpargumento tenha decorrido ou um sinal seja entregue ao encadeamento de chamada, e sua ação é invocar uma função de captura de sinal ou finalizar o processo. O tempo de suspensão pode ser maior que o solicitado, porque o valor do argumento é arredondado para um múltiplo inteiro da resolução de suspensão ou devido ao agendamento de outras atividades pelo sistema. Mas, exceto no caso de ser interrompido por um sinal, o tempo de suspensão não deve ser menor que o tempo especificado por rqtp, conforme medido pelo relógio do sistema CLOCK_REALTIME.

O uso da nanosleep()função não afeta a ação ou o bloqueio de qualquer sinal.

Além do sono , a seleção humilde com os conjuntos de descritores de arquivos NULL permitirá pausar com precisão de microssegundos e sem o risco de SIGALRMcomplicações.

sigtimedwait e sigwaitinfo oferecem comportamento semelhante.

#include <unistd.h>

int usleep(useconds_t useconds); //pass in microseconds

#include <stdio.h>
#include <stdlib.h>
int main () {

puts("Program Will Sleep For 2 Seconds");

system("sleep 2");      // works for linux systems


return 0;
}