在c中实现时间延迟

Question

我不知道如何确切地表达这个搜索..所以我没有找到任何东西..：S

我需要在C中实现时间延迟

。例如我想做一些事情，然后等待说 1 分钟，然后继续做事。

这有道理吗？有人可以帮我吗？

Answer 1

尝试sleep(int number_of_seconds)

Answer 2

sleep(int) 可以起到很好的延迟作用。一分钟：

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

Answer 3

是定时器吗？

对于 WIN32，请尝试 http://msdn.microsoft.com/ en-us/library/ms687012%28VS.85%29.aspx

Answer 4

你可以简单地调用delay()函数。因此，如果您想将进程延迟 3 秒，请调用delay(3000)...

Answer 5

如果您确定要等待并且永远不会被打断，请在 POSIX 中使用 sleep 或在 Windows 中使用 Sleep。在 POSIX 中，睡眠需要以秒为单位的时间，因此如果您希望时间更短，可以使用像 usleep() 这样的变体，它使用微秒。 Windows 中的睡眠需要几毫秒，您很少需要比这更细的粒度。

您可能希望等待一段时间，但又希望允许中断，也许是在紧急情况下。睡眠可以被信号中断，但在这种情况下有更好的方法。

因此，我实际上在实践中发现您所做的就是等待具有超时的事件或条件变量。

在 Windows 中，您的调用是 WaitForSingleObject。在 POSIX 中，它是 pthread_cond_timedwait。

在 Windows 中，您还可以使用 WaitForSingleObjectEx，然后您可以通过调用 QueueUserAPC 实际上“中断”线程并执行任何排队任务。 WaitForSingleObject(Ex) 将返回一个代码来确定它退出的原因，因此当它返回“TIMEDOUT”状态时您就会知道它确实超时了。当您希望它终止时，您可以设置它正在等待的事件。

使用pthread_cond_timedwait，您可以用信号广播条件变量。 （如果多个线程正在等待同一个线程，则需要广播来唤醒所有线程）。每次循环时都应该检查条件。您的线程可以获取当前时间并查看它是否已经过去，或者可以查看是否满足某些条件来确定要做什么。如果您有某种队列，您可以检查一下。 （您的线程将自动锁定一个互斥锁，用于等待条件变量，因此当它检查条件时，它可以单独访问它）。

Answer 6

// 提供延迟x毫秒的ANSI C方法

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void delayMillis(unsigned long ms) {
    clock_t start_ticks = clock();
    unsigned long millis_ticks = CLOCKS_PER_SEC/1000;
    while (clock()-start_ticks < ms*millis_ticks) {
    }
}    

/* 
 * Example output:
 * 
 * CLOCKS_PER_SEC:[1000000]
 * 
 * Test Delay of 800 ms....
 * 
 * start[2054], end[802058], 
 * elapsedSec:[0.802058]
 */
int testDelayMillis() {

    printf("CLOCKS_PER_SEC:[%lu]\n\n", CLOCKS_PER_SEC);
    clock_t start_t, end_t;
    start_t = clock();
    printf("Test Delay of 800 ms....\n", CLOCKS_PER_SEC);
    delayMillis(800); 
    end_t = clock();
    double elapsedSec = end_t/(double)CLOCKS_PER_SEC;
    printf("\nstart[%lu], end[%lu], \nelapsedSec:[%f]\n", start_t, end_t, elapsedSec);

}

int main() {    
    testDelayMillis();
}

Answer 7

C11 有一个专门用于此目的的函数：

#include <threads.h>
#include <time.h>
#include <stdio.h>

void sleep(time_t seconds) {
    struct timespec time;
    time.tv_sec = seconds;
    time.tv_nsec = 0;
    while (thrd_sleep(&time, &time)) {}
}

int main() {
    puts("Sleeping for 5 seconds...");
    sleep(5);
    puts("Done!");
    return 0;
}

请注意，该函数仅从 glibc 2.28 开始可用。

Answer 8

用于 gcc 中的 C 使用。
#include ;

然后使用 Sleep(); /// Sleep() 大写 S。而不是 sleep() 大写 s 。

//Sleep(1000) 是 1 秒 /// 也许。

clang 支持 sleep()，sleep(1) 是 1 秒的时间延迟/等待。

Answer 9

对于 Linux 操作系统上的短暂延迟（例如几微秒），您可以使用“usleep”：

// C Program to perform short delays
#include <unistd.h>
#include <stdio.h>

int main(){
    printf("Hello!\n");
    usleep(1000000); // For a 1-second delay
    printf("Bye!\n);
    return 0;

Answer 10

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

Answer 11

写下这段代码：

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");}

}

Answer 12

在标准 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”标记，这通常意味着便携式解决方案是可取的，尽管，当然，仍然可能会给出特定于供应商的解决方案）。

无论如何，如果您所在的平台提供了更有效的方式，请使用它。正如一些评论所指出的，像这样的紧密循环可能会存在与 CPU 相关的特定问题使用情况和电池寿命。

任何像样的时间切片操作系统都能够降低连续使用其完整时间片的任务的动态优先级，但电池电量可能会出现更多问题。

然而，C 没有指定有关托管环境中操作系统详细信息的任何内容，并且此答案仅适用于 ISO C 和 ISO C（因此不使用 sleep、select< /code>、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.
}

Answer 13

以下是在大多数桌面系统上执行此操作的方法：

#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
}

等待循环变量必须进行微调，这些变量对于我的计算机来说工作得非常接近，但是频率范围这使得现代桌面系统变得非常不精确；所以不要在那里使用，除非你是裸露的金属并且不做这样的事情。

Answer 14

检查 sleep(3) 手册页 或 MSDN for Sleep

Answer 15

尽管许多实现都有 time 函数返回当前时间时间以秒为单位，不能保证每个实现都会这样做（例如，有些可能返回毫秒而不是秒 >）。因此，更便携的解决方案是使用 difftime 函数。

C 标准保证 difftime 返回两个 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(¤t);

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

---

关于 time 和 difftime 函数的一个警告是，C 标准从未指定粒度。大多数实现的粒度为一秒。虽然这对于持续几秒的延迟来说是可以的，但对于持续一秒的延迟，我们的延迟函数可能会等待太长时间。

有一个可移植的标准 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：时钟函数的粒度留给实现。例如，具有 32 位 clock_t 值且分辨率以微秒为单位的机器可能最终会在 2147 秒后包装 clock 返回的值（约36分钟）。

因此，考虑使用延迟函数的 time 和 difftime 实现来实现持续至少一秒的延迟，以及 clock< /code> 延迟持续一秒的实现。

最后要注意的是：clock 返回处理器时间而不是日历时间； 时钟可能与实际经过的时间不符（例如，如果进程休眠）。

Answer 16

对于长达一分钟的延迟，sleep() 是一个不错的选择。

如果有一天，您想要在小于一秒的延迟上暂停，您可能需要考虑超时的 poll() 。

两者都是 POSIX。

Answer 17

C11 之前的 C 标准库中没有 sleep() 函数，但 POSIX 确实提供了一些选项。

POSIX 函数 sleep() (unistd.h) 需要一个 unsigned int 参数，表示所需睡眠的秒数。尽管这不是标准库函数，但它被广泛使用，并且即使在使用 --std=c11 等更严格的设置进行编译时，glibc 似乎也支持它。

POSIX 函数 nanosleep() ( time.h) 将两个指向 timespec 结构的指针作为参数，并提供对睡眠持续时间的更精细的控制。第一个参数指定延迟持续时间。如果第二个参数不是空指针，则它保存调用被信号处理程序中断时剩余的时间。

使用 nanosleep() 函数的程序可能需要包含 功能测试宏以便编译。当我使用典型的编译器调用 gcc -std=c11 -Wall -Wextra -Wpedantic 时，如果没有功能测试宏，以下代码示例将无法在我的 Linux 系统上进行编译。

POSIX 曾经有一个 usleep() 函数（unistd. h) 使用 useconds_t 参数来指定睡眠持续时间（以微秒为单位）。当与严格的编译器设置一起使用时，该函数还需要一个功能测试宏。唉，usleep() 已随 POSIX.1-2001 废弃，不应再使用。建议现在使用 nanosleep() 而不是 usleep()。

#define _POSIX_C_SOURCE  199309L     // feature test macro for nanosleep()

#include <stdio.h>
#include <unistd.h>    // for sleep()
#include <time.h>      // for nanosleep()

int main(void)
{
    // use unsigned sleep(unsigned seconds)
    puts("Wait 5 sec...");
    sleep(5);

    // use int nanosleep(const struct timespec *req, struct timespec *rem);
    puts("Wait 2.5 sec...");
    struct timespec ts = { .tv_sec = 2,          // seconds to wait
                           .tv_nsec = 5e8 };     // additional nanoseconds
    nanosleep(&ts, NULL);
    puts("Bye");

    return 0;
}

附录：

C11 确实有标头 threads.h 提供 thrd_sleep()，其工作方式与nanosleep()相同。直到 2018 年，随着 threads.h >glibc 2.28。一般来说，很难找到支持 threads.h 的实现（Clang 很长一段时间都不支持它，但我不确定那里的当前状况）。您必须小心使用此选项。