C++ Timer Utilities | "타이머 유틸리티" 가이드

타이머 유틸리티란?

시간 지연 및 측정

#include <thread>
#include <chrono>
using namespace std::chrono_literals;

// 지연
std::this_thread::sleep_for(1s);

// 특정 시간까지
auto wakeup = std::chrono::system_clock::now() + 5s;
std::this_thread::sleep_until(wakeup);

sleep_for

using namespace std::chrono_literals;

// 밀리초
std::this_thread::sleep_for(100ms);

// 초
std::this_thread::sleep_for(2s);

// 분
std::this_thread::sleep_for(1min);

실전 예시

예시 1: 주기적 작업

using namespace std::chrono_literals;

void periodicTask() {
    while (true) {
        // 작업 수행
        std::cout << "작업 실행" << std::endl;
        
        // 1초 대기
        std::this_thread::sleep_for(1s);
    }
}

예시 2: sleep_until

using namespace std::chrono;
using namespace std::chrono_literals;

void scheduledTask() {
    auto now = system_clock::now();
    auto nextRun = now + 5s;
    
    std::cout << "5초 후 실행 예정" << std::endl;
    std::this_thread::sleep_until(nextRun);
    
    std::cout << "작업 실행" << std::endl;
}

예시 3: 정밀 타이머

using namespace std::chrono;
using namespace std::chrono_literals;

class PrecisionTimer {
    steady_clock::time_point start;
    
public:
    PrecisionTimer() : start(steady_clock::now()) {}
    
    void waitFor(milliseconds duration) {
        auto target = start + duration;
        
        while (steady_clock::now() < target) {
            std::this_thread::yield();  // CPU 양보
        }
    }
    
    auto elapsed() const {
        return duration_cast<microseconds>(
            steady_clock::now() - start
        );
    }
};

int main() {
    PrecisionTimer timer;
    timer.waitFor(100ms);
    
    std::cout << "경과: " << timer.elapsed().count() << "μs" << std::endl;
}

예시 4: 타임아웃

using namespace std::chrono;
using namespace std::chrono_literals;

bool waitForCondition(milliseconds timeout) {
    auto deadline = steady_clock::now() + timeout;
    
    while (steady_clock::now() < deadline) {
        if (checkCondition()) {
            return true;
        }
        
        std::this_thread::sleep_for(10ms);
    }
    
    return false;  // 타임아웃
}

int main() {
    if (waitForCondition(5s)) {
        std::cout << "조건 충족" << std::endl;
    } else {
        std::cout << "타임아웃" << std::endl;
    }
}

yield

// CPU 양보
std::this_thread::yield();

// 바쁜 대기에서 사용
while (!ready) {
    std::this_thread::yield();
}

자주 발생하는 문제

문제 1: 정확도

using namespace std::chrono_literals;

// sleep은 최소 시간 보장
// 실제로는 더 길 수 있음
auto start = std::chrono::steady_clock::now();
std::this_thread::sleep_for(100ms);
auto end = std::chrono::steady_clock::now();

auto actual = duration_cast<milliseconds>(end - start);
std::cout << "실제: " << actual.count() << "ms" << std::endl;
// 출력: 실제: 102ms (예시)

문제 2: 시계 선택

// ❌ system_clock (시간 변경 영향)
auto wakeup = std::chrono::system_clock::now() + 5s;
std::this_thread::sleep_until(wakeup);
// 시스템 시간 변경 시 문제

// ✅ steady_clock
auto wakeup = std::chrono::steady_clock::now() + 5s;
std::this_thread::sleep_until(wakeup);

문제 3: 바쁜 대기

// ❌ CPU 100% 사용
while (!ready) {
    // 바쁜 대기
}

// ✅ yield 사용
while (!ready) {
    std::this_thread::yield();
}

// ✅ sleep 사용
while (!ready) {
    std::this_thread::sleep_for(1ms);
}

문제 4: 짧은 sleep

// 매우 짧은 sleep은 부정확
std::this_thread::sleep_for(std::chrono::microseconds(1));
// 실제로는 더 오래 걸림

// OS 스케줄러 한계

시간 측정

using namespace std::chrono;

auto start = steady_clock::now();

// 작업
std::this_thread::sleep_for(100ms);

auto end = steady_clock::now();
auto elapsed = duration_cast<milliseconds>(end - start);

std::cout << "경과: " << elapsed.count() << "ms" << std::endl;

타이머 구현 패턴

표준 스레드 API만으로도 다음 패턴이 자주 쓰입니다.

1. 상대 지연: sleep_for(duration) — “지금부터 최소 d만큼” (OS 스케줄러에 따라 더 길어질 수 있음).
2. 절대 시각까지: sleep_until(time_point) — 특정 steady_clock 또는 system_clock 시각까지. 주기 작업에서 드리프트를 줄일 때 유용합니다.
3. 폴링 + 짧은 sleep: 조건을 주기적으로 확인하며 CPU를 나누 씁니다. sleep_for(0) 또는 yield만으로는 스핀에 가까울 수 있어, 밀리초 단위 폴링이 일반적입니다.
4. 데드라인 기반: auto deadline = steady_clock::now() + timeout 후 now() < deadline 루프 — steady_clock 글과 동일한 원칙입니다.

using namespace std::chrono_literals;

void fixed_rate_loop() {
    auto next = std::chrono::steady_clock::now();
    const auto interval = 1s;
    for (int i = 0; i < 10; ++i) {
        next += interval;
        do_tick();
        std::this_thread::sleep_until(next);  // 누적 시각 기준으로 드리프트 완화
    }
}

Asio(Boost.Asio) 타이머와의 연계

비동기 I/O를 쓰는 서버·클라이언트에서는 스레드 sleep 대신 asio::steady_timer / asio::system_timer로 이벤트 루프에 타이머를 등록하는 방식이 일반적입니다.

• steady_timer: 내부적으로 단조 시계에 대응. 타임아웃·재전송 간격·하트비트에 적합합니다.
• system_timer: wall-clock 기준. 특정 시각에 실행하거나 로그와 맞춘 스케줄이 필요할 때 사용합니다.

개념적으로는 async_wait에 핸들러를 넘기고, 취소는 timer.cancel()입니다. 네트워크 가이드와 연결해 보려면 C++ 네트워크 가이드 — post·dispatch·defer에서 실행 스트랜드와 함께 읽는 것이 좋습니다.

// 개념 스케치 (실제 코드는 io_context, executor 설정 필요)
// asio::steady_timer t(io, std::chrono::steady_clock::now() + 5s);
// t.async_wait([](std::error_code ec) { if (!ec) { /* 타임아웃 처리 */ } });

스레드 sleep과의 차이: Asio 타이머는 해당 스레드를 블록하지 않고 다른 연결 처리를 계속할 수 있습니다(단일 스레드 io_context 모델에서 특히).

주기적 작업 (심화)

• 고정 간격(fixed rate): 루프마다 sleep_for(interval)만 쓰면 작업 시간만큼 누적 지연이 생깁니다. 위의 next += interval; sleep_until(next) 패턴이 더 균일합니다.
• 백오프: 네트워크 재시도에서는 지수 백오프 + 상한(jitter 포함)을 두어 서버·클라이언트 모두 보호합니다.
• 정지: 장시간 루프는 std::stop_token(C++20) 또는 원자적 bool로 종료를 받아 sleep을 중단할 수 있게 설계합니다.

실전: 리트라이와 타임아웃

전체 데드라인 하나 + 시도마다 짧은 대기가 읽기 쉽습니다.

#include <chrono>
#include <thread>

template <class Fn>
bool retry_with_deadline(Fn&& fn, std::chrono::steady_clock::time_point deadline,
                         std::chrono::milliseconds backoff) {
    while (std::chrono::steady_clock::now() < deadline) {
        if (fn()) return true;
        std::this_thread::sleep_for(backoff);
    }
    return false;
}

• HTTP/gRPC 클라이언트: 연결 타임아웃과 읽기 타임아웃을 분리하고, 재시도는 멱등한 요청에만 적용하는 것이 안전합니다.
• 조건 변수: 대기 가능하면 wait_until(lock, deadline)이 폴링보다 효율적입니다.

성능 고려사항

• sleep_for(1µs) 같은 극단: 많은 OS에서 실제 최소 수십~수백 µs로 올라갑니다. 고주기 타이머가 필요하면 OS별 타이머 API나 오디오/게임 루프용 전용 스레드를 검토합니다.
• 짧은 루프 + sleep: 폴링 간격이 너무 짧으면 깨어나는 빈도가 높아 전력·CPU 비용이 커집니다. 요구 정밀도에 맞춰 최소 폴링 간격을 정합니다.
• 바쁜 대기: yield만 반복하면 여전히 코어를 점유할 수 있습니다. **짧은 sleep**이나 락·조건 변수로 블록하는 편이 낫습니다.
• 다수 스레드: 각 스레드가 자기만 sleep하는 것은 괜찮지만, 수천 개 스레드가 각각 sleep을 깨우면 스케줄러 부담이 커집니다. 이벤트 루프 + 타이머 큐 한 개로 합치는 방식을 고려합니다.

---

FAQ

Q1: sleep_for는?

A: 지정 시간 대기.

Q2: sleep_until?

A: 특정 시점까지 대기.

Q3: yield?

A: CPU 양보. 바쁜 대기 완화.

Q4: 정확도?

A: 최소 시간 보장. 실제는 더 길 수 있음.

Q5: 짧은 sleep?

A: OS 스케줄러 한계. 부정확.

Q6: 학습 리소스는?

A:

• “C++ Concurrency in Action”
• cppreference.com
• “C++ Primer”

---

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

• C++ Chrono | “시간” 라이브러리 완벽 가이드
• C++ Chrono | “시간 라이브러리” 가이드
• C++ steady_clock | “안정 시계” 가이드

관련 글

• C++ Chrono 완벽 가이드 |
• C++ Calendar & Timezone |
• C++ Chrono Literals |
• C++ Chrono 상세 가이드 |
• C++ duration |