Реализовать временную задержку в c

Я не знаю точно, как сложить поиск для этого.. так что мне не повезло найти что-нибудь..: S

Мне нужно реализовать временную задержку в C.

например, я хочу сделать что-то, а потом подождите 1 минуту, а затем продолжайте делать вещи.

Это имело смысл? Может ли кто-нибудь помочь мне?

Ответ 1

В стандарте C (C99) вы можете использовать time() для этого, например:

#include <time.h>
:
void waitFor (unsigned int secs) {
    unsigned int retTime = time(0) + secs;   // Get finishing time.
    while (time(0) < retTime);               // Loop until it arrives.
}

Кстати, это предполагает, что time() возвращает значение разрешения 1 секунду. Я не думаю, что это предусмотрено стандартом, поэтому вам, возможно, придется приспособиться к нему.

Чтобы прояснить, это единственный способ, которым я знаю это сделать с ISO C99 (и вопрос отмечен не более чем "C", что обычно означает, что переносные решения желательны, хотя, конечно же, поставщик могут быть предоставлены конкретные решения).

В любом случае, если вы находитесь на платформе, которая обеспечивает более эффективный способ, используйте ее. Как указано в нескольких комментариях, могут возникнуть определенные проблемы с жестким циклом, подобным этому, в отношении использования ЦП и времени автономной работы.

Любая подходящая ОС с временным сокращением может отбросить динамический приоритет задачи, которая постоянно использует свой полный временной срез, но может быть более проблематичным питание от батареи.

Однако C не указывает ничего о деталях ОС в размещенной среде, и этот ответ относится только к ISO C и ISO C (поэтому не нужно использовать вызовы sleep, select, Win32 API или что-то в этом роде).

И имейте в виду, что POSIX sleep может быть прерван сигналами. Если вы собираетесь идти по этому пути, вам нужно сделать что-то вроде:

int finishing = 0; // set finishing in signal handler 
                   // if you want to really stop.

void sleepWrapper (unsigned int secs) {
    unsigned int left = secs;
    while ((left > 0) && (!finishing)) // Don't continue if signal has
        left = sleep (left);           //   indicated exit needed.
}

Ответ 2

Вот как вы можете сделать это на большинстве настольных систем:

#ifdef _WIN32
    #include <windows.h>
#else
    #include <unistd.h>
#endif

void wait( int seconds )
{   // Pretty crossplatform, both ALL POSIX compliant systems AND Windows
    #ifdef _WIN32
        Sleep( 1000 * seconds );
    #else
        sleep( seconds );
    #endif
}

int
main( int argc, char **argv)
{
    int running = 3;
    while( running )
    {   // do something
        --running;
        wait( 3 );
    }
    return 0; // OK
}

Вот как вы можете это сделать на микрокомпьютере/процессоре без таймера:

int wait_loop0 = 10000;
int wait_loop1 = 6000;

// for microprocessor without timer, if it has a timer refer to vendor documentation and use it instead.
void
wait( int seconds )
{   // this function needs to be finetuned for the specific microprocessor
    int i, j, k;
    for(i = 0; i < seconds; i++)
    {
        for(j = 0; j < wait_loop0; j++)
        {
            for(k = 0; k < wait_loop1; k++)
            {   // waste function, volatile makes sure it is not being optimized out by compiler
                int volatile t = 120 * j * i + k;
                t = t + 5;
            }
        }
    }
}

int
main( int argc, char **argv)
{
    int running = 3;
    while( running )
    {   // do something
        --running;
        wait( 3 );
    }
    return 0; // OK
}

Переменные waitloop должны быть точно настроены, они действительно работают очень близко для моего компьютера, но частотная шкала делает ее очень неточной для современной настольной системы; Так что не используйте там, если вы не готовы к металлу и не делаете такие вещи.

Ответ 3

Отметьте sleep (3) man page или MSDN для сна

Ответ 4

Хотя во многих реализациях функция time возвращает текущее время в секундах, нет никакой гарантии, что каждая реализация будет делать это ( например, некоторые могут возвращать миллисекунды, а не секунды). Таким образом, более портативным решением является использование функции difftime.

difftime гарантируется стандартом C, чтобы вернуть разницу во времени между секундами между двумя значениями time_t. Таким образом, мы можем написать портативную функцию задержки времени, которая будет работать во всех совместимых реализациях C.

#include <time.h>

void delay(double dly){
    /* save start time */
    const time_t start = time(NULL);

    time_t current;
    do{
        /* get current time */
        time(&current);

        /* break loop when the requested number of seconds have elapsed */
    }while(difftime(current, start) < dly);
}

Одно из предостережений с функциями time и difftime состоит в том, что Стандарт никогда не определяет детализацию. Большинство реализаций имеют степень детализации в одну секунду. Хотя это подходит для задержек, длившихся несколько секунд, наша функция задержки может ждать слишком долго, чтобы задержки длились менее одной секунды.

Существует переносная стандартная альтернатива C: функция clock.

Функция clock возвращает наилучшее приближение реализаций к процессорному времени, используемому программой, начиная с эпохи реализации, связанной только с вызовом программы. Чтобы определить время в секундах, значение, возвращаемое функцией clock, должно быть разделено на значение макроса CLOCKS_PER_SEC.

Решение функции clock очень похоже на наше решение функции time:

#include <time.h>

void delay(double dly){
    /* save start clock tick */
    const clock_t start = clock();

    clock_t current;
    do{
        /* get current clock tick */
        current = clock();

        /* break loop when the requested number of seconds have elapsed */
    }while((double)(current-start)/CLOCKS_PER_SEC < dly);
}

В этом случае существует оговорка, аналогичная описанной в time и difftime: гранулярность функции clock оставлена для реализации. Например, машины с 32-разрядными значениями для clock_t с разрешением в микросекундах могут обернуть значение, возвращаемое clock через 2147 секунд (около 36 минут).

Таким образом, рассмотрите возможность использования time и difftime реализации функции задержки для задержек продолжительностью не менее одной секунды и реализации clock для задержек, длившихся менее одной секунды.

Последнее слово предостережения: clock возвращает время процессора, а не время календаря; clock может не соответствовать фактическому истекшему времени (например, если процесс засыпает).

Ответ 5

При задержке, равной одной минуте, sleep() - хороший выбор.

Если когда-нибудь вы захотите сделать паузу на задержках менее одной секунды, вы можете рассмотреть poll() с таймаутом.

Оба являются POSIX.

Ответ 6

sleep(int) работает как хорошая задержка. На минуту:

//Doing some stuff...
sleep(60); //Freeze for A minute
//Continue doing stuff...

Ответ 7

Это timer?

Для WIN32 попробуйте http://msdn.microsoft.com/en-us/library/ms687012%28VS.85%29.aspx

Ответ 8

Попробуйте sleep(int number_of_seconds)

Ответ 9

вы можете просто вызвать функцию delay(). Поэтому, если вы хотите отложить процесс за 3 секунды, задержка вызова (3000)...

Ответ 10

Если вы уверены, что хотите подождать и не прерваться, используйте sleep в POSIX или Sleep в Windows. В POSIX sleep требуется время в секундах, поэтому, если вы хотите, чтобы время было короче, есть разновидности типа usleep(), который использует микросекунды. Сон в Windows занимает миллисекунды, редко вам нужна более тонкая гранулярность.

Возможно, вы хотите подождать некоторое время, но хотите разрешить прерывания, возможно, в случае чрезвычайной ситуации. сон может быть прерван сигналами, но есть лучший способ сделать это в этом случае.

Поэтому я фактически нашел на практике то, что вы делаете, это ждать события или переменной условия с таймаутом.

В Windows ваш вызов WaitForSingleObject. В POSIX это pthread_cond_timedwait.

В Windows вы также можете использовать WaitForSingleObjectEx, а затем вы можете "прервать" поток с помощью любой задачи в очереди, вызвав QueueUserAPC. WaitForSingleObject (Ex) вернет код, определяющий, почему он вышел, поэтому вы узнаете, когда он вернет статус "TIMEDOUT", который действительно запустил время. Вы устанавливаете Событие, которое оно ожидает, когда вы хотите, чтобы он завершился.

С помощью pthread_cond_timedwait вы можете сигнализировать трансляцию переменной условия. (Если несколько потоков ждут на одном и том же, вам нужно будет транслировать, чтобы разбудить их все). Каждый раз, когда он петли, он должен проверять состояние. Ваш поток может получить текущее время и посмотреть, прошел ли он, или он может посмотреть, было ли выполнено какое-либо условие, чтобы определить, что делать. Если у вас есть какая-то очередь, вы можете ее проверить. (В вашем потоке автоматически будет заблокирован мьютекс, который он использовал для ожидания переменной условия, поэтому, когда он проверяет условие, у него есть единственный доступ к нему).

Ответ 11

system("timeout /t 60"); // waits 60s. this is only for windows vista,7,8
system("ping -n 60 127.0.0.1 >nul"); // waits 60s. for all windows

Ответ 12

Введите этот код:

void delay(int x)
{   int i=0,j=0;
    for(i=0;i<x;i++){for(j=0;j<200000;j++){}}
}

int main()
{
    int i,num;

    while(1) {

    delay(500);

    printf("Host name");
    printf("\n");}

}