c에서 시간 지연을 실행합니다.

c에서 시간 지연을 실행합니다.

이 검색어를 정확히 어떻게 써야 할지 모르겠습니다.그래서 운 좋게도 아무것도 못 찾았는데요.. :S

저는 C에서 시간 지연을 시행해야 합니다.

예를 들어, 나는 무언가를 하고싶습니다. 그리고 나서 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"만 태그가 지정되어 있어 휴대용 솔루션이 바람직하지만 물론 벤더별 솔루션도 제공될 수 있습니다.

반드시 보다 효율적인 방법을 제공하는 플랫폼에 있다면 이를 사용하십시오.여러 의견에서 알 수 있듯이, CPU 사용량 및 배터리 수명과 관련하여 이와 같은 엄격한 루프에 특정한 문제가 있을 수 있습니다.

적절한 타임슬라이싱 OS라면 전체 타임슬라이싱을 지속적으로 사용하는 작업의 동적 우선 순위를 떨어뜨릴 수 있지만 배터리 전력은 더 문제가 될 수 있습니다.

그러나 C는 호스트 환경의 OS 세부 정보에 대해 아무것도 지정하지 않으며, 이 대답은 ISO C 및 ISO C 단독에 대한 것입니다(따라서 사용하지 않음).sleep,select Win32 API ).

그리고 POSIX는 신호에 의해 방해될 수 있다는 것을 기억하세요.그 길을 내려가려면 다음과 같은 작업을 수행해야 합니다.

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

대부분의 데스크톱 시스템에서 이를 수행할 수 있는 방법은 다음과 같습니다.

#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 변수는 미세 조정이 되어야 합니다. 제 컴퓨터에서는 거의 작동했지만, 주파수 척도 때문에 현대적인 데스크톱 시스템에서는 매우 부정확합니다. 따라서 금속을 완전히 벗어서 그런 작업을 하지 않는 한 사용하지 마십시오.

sleep(3) man page 또는 MSDN에서 sleep 확인

많은 구현이 초 단위로 현재 시간을 반환하는 기능을 가지고 있지만, 모든 구현이 이 기능을 수행한다는 보장은 없습니다(예: 초 단위가 아닌 밀리초 단위로 반환되는 경우도 있습니다).이와 같이, 더 휴대하기 쉬운 해결책은 그 기능을 사용하는 것입니다.

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 표준이 세분화를 지정하지 않는다는 것입니다.대부분의 구현은 1초의 세부사항을 갖습니다.몇 초 동안의 지연은 괜찮지만, 지연 기능은 1초 미만의 지연을 위해 너무 오래 기다릴 수 있습니다.

휴대용 표준 C 대안이 있습니다.clock기능.

이 함수는 프로그램 호출과 관련된 구현 정의 시대가 시작된 이래로 구현의 최적 근사치를 프로그램이 사용한 프로세서 시간으로 반환합니다.시간(초)을 결정하려면 함수가 반환하는 값을 매크로 값으로 나누어야 합니다.

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마이크로초 단위의 해상도로 반환되는 값을 랩핑할 수 있습니다.clock2147초 후(약 36분).

이와 같이, 사용을 고려해 보십시오.time그리고.difftime최소 1초 이상 지속되는 지연에 대한 지연 함수의 구현, 그리고clock1초 미만의 지연에 대한 이행

마지막으로 주의를 당부합니다.clock캘린더 시간이 아닌 프로세서 시간을 반환합니다.clock실제 경과 시간과 일치하지 않을 수 있습니다(예: 프로세스가 슬립 상태인 경우).

1분 정도의 지연에 대해서는sleep()좋은 선택입니다.

언젠가 1초보다 작은 지연으로 잠시 멈추고 싶다면 다음을 고려해 볼 수 있습니다.poll()타임아웃으로

둘 다 POSIX입니다.

없습니다sleep()C11 C 이전의 표준 라이브러리에서 기능하지만, POSIX는 몇 가지 옵션을 제공합니다.

POSIX 함수(unistd.h)는 다음을 수행합니다.unsigned int잠자기 원하는 시간(초)을 나타내는 인수입니다.이것은 Standard Library 기능은 아니지만 널리 사용할 수 있으며 glibc는 다음과 같은 더 엄격한 설정으로 컴파일할 때에도 지원하는 것으로 보입니다.--std=c11.

POSIX 함수(time.h)는 다음과 같은 두 가지 포인터를 사용합니다.timespec구조를 인수로 사용하고 수면 시간에 대한 보다 세밀한 제어를 제공합니다.첫 번째 인수는 지연 기간을 지정합니다.두 번째 인수가 널 포인터가 아닌 경우 신호 처리기에 의해 통화가 중단된 경우 남은 시간을 유지합니다.

를 사용하는 프로그램nanosleep()함수를 컴파일하려면 피쳐 테스트 매크로를 포함해야 할 수도 있습니다.다음 코드 샘플은 내가 일반적인 컴파일러 호출을 사용할 때 특징 테스트 매크로 없이 내 리눅스 시스템에서 컴파일되지 않을 것입니다.gcc -std=c11 -Wall -Wextra -Wpedantic.

POSIX는 한때 다음과 같은 기능(unistd.h)을 가지고 있었습니다.useconds_tmicroseconds 단위로 sleep duration을 지정하는 인수입니다.또한 이 기능은 엄격한 컴파일러 설정과 함께 사용할 때 특징 테스트 매크로가 필요했습니다.아,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제공, 에 동일하게 작동하는nanosleep(). GCC가 지원하지 않음threads.h2018년까지 glibc 2.28이 출시되었습니다.지원을 통해 구현을 찾는 것은 일반적으로 어려웠습니다.threads.h(클랑은 오랫동안 지지하지 않았지만 그곳의 현재 상황에 대해서는 잘 모르겠습니다.주의해서 이 옵션을 사용해야 합니다.

.sleep(int number_of_seconds)

sleep(int)상당한 지연으로 작용합니다.잠시동안:

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

그런가요?timer?

WIN32의 경우 http://msdn.microsoft.com/en-us/library/ms687012%28VS.85%29.aspx 을 이용해 보십시오.

간단히 지연 () 함수를 호출할 수 있습니다.따라서 3초 안에 처리를 지연시키려면 지연(3000)을 호출합니다.

기다리면서 방해받지 않으려면 POSIX에서 절전 또는 Windows에서 절전을 사용합니다.POSIX에서 수면시간은 몇초 안에 걸리므로 더 짧은 시간을 원한다면 다음과 같은 다양한 것들이 있습니다.usleep()마이크로초를 사용합니다.Windows에서 절전 모드를 실행하는 데는 밀리초가 소요됩니다. 이보다 더 세분화된 작업이 필요한 경우는 거의 없습니다.

당신이 일정 시간을 기다리기를 원할지도 모르지만, 아마도 긴급한 경우에, 방해를 허용하기를 원할 수도 있습니다. 신호에 의해 수면이 방해될 수 있지만, 이 경우에는 더 나은 방법이 있습니다.

그래서 실제로 당신이 하는 일은 이벤트나 타임아웃 상태의 조건 변수를 기다리는 것입니다.

윈도우에서 당신의 전화는WaitForSingleObject에서는 . 입니다.pthread_cond_timedwait.

Windows(윈도우)에서도 사용할 수 있습니다.WaitForSingleObjectEx그러면 실제로 호출을 통해 대기 중인 작업에 대해 스레드를 "interrupt"할 수 있습니다.QueueUserAPC는 을 알 수 WaitForSingleObject(Ex)는 종료된 이유를 결정하는 코드를 반환하므로, "TIMEDOUT" 상태를 반환할 때 실제로 시간 초과되었음을 알 수 있습니다.이벤트를 종료할 때 대기 중인 이벤트를 설정합니다.

와 함께pthread_cond_timedwait조건 변수를 브로드캐스트하는 신호를 보낼 수 있습니다.(여러 스레드가 동일한 스레드에서 대기 중인 경우 해당 스레드를 모두 깨우기 위해 브로드캐스트해야 합니다.)루프를 할 때마다 상태를 확인해야 합니다.스레드는 현재 시간을 파악하여 시간이 지났는지 확인하거나 어떤 조건이 충족되었는지 확인하여 작업을 결정할 수 있습니다.대기열 종류가 있으면 확인할 수 있습니다. (스레드에는 자동으로 뮤텍스가 잠겨 있어서 상태 변수에서 대기하던 것이 자동으로 잠기므로 상태를 확인할 때는 해당 스레드에 단독으로 액세스할 수 있습니다.)

// x밀리초 지연 ANSIC 방법 제공

#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();
}

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부터만 사용할 수 있습니다.

GCC를 사용하는 경우.#include <창문>.h>

Sleep(); // Sleep()을 s로 사용하지 않고 S로 사용합니다.

//Sleep(1000)은 1초///일 수 있습니다.

clang에서 수면 지원 (), sleep(1)은 1초 지연/대기입니다.

리눅스 OS에서 짧은 지연(예: 마이크로초)이 발생하는 경우 "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;

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

다음 코드 작성:

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

}

언급URL : https://stackoverflow.com/questions/3930363/implement-time-delay-in-c