steady_clock과 system_clock 차이는?

steady_clock은 단조 증가를 보장해 경과 시간·타임아웃 측정에 쓰고, system_clock은 실제 시각(UTC 기준) 표현에 씁니다. NTP 조정에 시계가 뒤로 갈 수 있으면 후자는 간격 측정에 부적합할 수 있습니다.

벤치마크에는 무엇을 쓰나요?

CPU 사이클이 아니라면 steady_clock 또는 고해상도 타이머를 쓰고, 여러 번 반복해 분산을 보는 편이 안전합니다.

now() 두 번 빼면 항상 정확한가요?

대략적인 경과는 맞지만 최적화·인라인에 따라 미세한 오차가 있습니다. 나노초 단위 미세 벤치마크는 전용 API를 검토하세요.

윈·리눅스에서 해상도가 다른데 문제되나요?

구현에 따라 다릅니다. 크로스 플랫폼 비교는 같은 빌드에서 상대 측정을 하고, 절대값은 문서를 확인하세요.

C++ steady_clock | '안정 시계' 가이드

2026년 3월 12일 · 17분 읽기 · 수정 2026년 4월 7일 중급 튜토리얼

이 글의 핵심

auto start = std::chrono::steady_clock::now();.

steady_clock이란?

단조 증가하는 시계 (C++11)

C/C++ 예제 코드입니다.

#include <chrono>

auto start = std::chrono::steady_clock::now();
// 작업
auto end = std::chrono::steady_clock::now();
auto elapsed = end - start;

특징

C/C++ 예제 코드입니다.

// 단조 증가 보장
// - 시스템 시간 변경 영향 없음
// - 항상 증가
// - 성능 측정에 적합

std::chrono::steady_clock::is_steady;  // true

실전 예시

예시 1: 벤치마크

template<typename Func>
auto benchmark(Func f) {
    auto start = std::chrono::steady_clock::now();
    
    f();
    
    auto end = std::chrono::steady_clock::now();
    return std::chrono::duration_cast<std::chrono::microseconds>(
        end - start
    );
}

int main() {
    auto duration = benchmark( {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    });
    
    std::cout << "실행 시간: " << duration.count() << "μs" << std::endl;
}

예시 2: 타이머 클래스

class Timer {
    std::chrono::steady_clock::time_point start;
    
public:
    Timer() : start(std::chrono::steady_clock::now()) {}
    
    void reset() {
        start = std::chrono::steady_clock::now();
    }
    
    auto elapsed() const {
        auto end = std::chrono::steady_clock::now();
        return std::chrono::duration_cast<std::chrono::milliseconds>(
            end - start
        );
    }
};

int main() {
    Timer timer;
    
    // 작업
    std::this_thread::sleep_for(std::chrono::seconds(1));
    
    std::cout << "경과: " << timer.elapsed().count() << "ms" << std::endl;
}

예시 3: 타임아웃

bool waitWithTimeout(std::chrono::milliseconds timeout) {
    auto start = std::chrono::steady_clock::now();
    
    while (true) {
        if (isReady()) {
            return true;
        }
        
        auto now = std::chrono::steady_clock::now();
        if (now - start >= timeout) {
            return false;  // 타임아웃
        }
        
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

예시 4: 성능 비교

void comparePerformance() {
    auto duration1 = benchmark(algorithm1);
    auto duration2 = benchmark(algorithm2);
    
    if (duration1 < duration2) {
        std::cout << "algorithm1이 더 빠름" << std::endl;
    }
    
    auto diff = duration2 - duration1;
    std::cout << "차이: " << diff.count() << "μs" << std::endl;
}

system_clock vs steady_clock

C/C++ 예제 코드입니다.

// system_clock: 시스템 시간 (변경 가능)
auto sys = std::chrono::system_clock::now();

// steady_clock: 단조 증가 (변경 불가)
auto steady = std::chrono::steady_clock::now();

// 성능 측정: steady_clock 사용

자주 발생하는 문제

문제 1: 시계 선택

C/C++ 예제 코드입니다.

// ❌ system_clock (시간 변경 영향)
auto start = std::chrono::system_clock::now();
// 시스템 시간 1시간 뒤로
auto end = std::chrono::system_clock::now();
// 음수 duration

// ✅ steady_clock
auto start = std::chrono::steady_clock::now();
auto end = std::chrono::steady_clock::now();
// 항상 양수

문제 2: 정밀도

// steady_clock 정밀도는 플랫폼 의존
using period = std::chrono::steady_clock::period;
std::cout << "정밀도: " << period::num << "/" << period::den << "s" << std::endl;

문제 3: 오버헤드

C/C++ 예제 코드입니다.

// 시계 호출 자체도 시간 소요
auto start = std::chrono::steady_clock::now();
auto end = std::chrono::steady_clock::now();

auto overhead = end - start;
std::cout << "오버헤드: " << overhead.count() << "ns" << std::endl;

문제 4: 긴 측정

C/C++ 예제 코드입니다.

// 매우 긴 측정 시 오버플로우 주의
auto start = std::chrono::steady_clock::now();

// 며칠 후
auto end = std::chrono::steady_clock::now();

// duration 타입 확인

활용 패턴

C/C++ 예제 코드입니다.

// 1. 벤치마크
auto duration = benchmark(func);

// 2. 타임아웃
bool success = waitWithTimeout(1000ms);

// 3. 성능 비교
compareAlgorithms();

// 4. 프로파일링
profileFunction();

steady_clock vs system_clock vs high_resolution_clock

C++11 chrono에는 대표적으로 세 시계가 있습니다. 이름만 보고 “항상 high_resolution이 가장 좋다”고 고르면 오히려 이식성이 나빠질 수 있습니다.

시계	단조 증가(steady)	의미 있는 절대 시각	일반적 용도
`steady_clock`	보장 (`is_steady == true`)	epoch는 구현 정의, “몇 시”로 쓰기 어려움	경과 시간, 데드라인, 타임아웃, 벤치마크
`system_clock`	아님 (NTP·수동 조정 영향)	wall-clock, `to_time_t` 등과 연동	로그 시각, 파일·DB 타임스탬프, 만료일(캘린더 의미)
`high_resolution_clock`	구현에 따라 다름	종종 `steady_clock` 또는 `system_clock`의 별칭	짧은 구간 측정(단, 이식성 주의)

high_resolution_clock 주의: 표준은 이 타입이 steady_clock이나 system_clock의 typedef일 수 있다고만 규정합니다. 따라서 절대 시각이 필요하면 system_clock, 경과·타임아웃이면 steady_clock을 직접 쓰는 편이 예측 가능합니다. high_resolution_clock은 “이식성보다 로컬 마이크로벤치”에 가깝습니다.

#include <chrono>
#include <iostream>

int main() {
    using namespace std::chrono;
    std::cout << std::boolalpha;
    std::cout << "steady_clock::is_steady: " << steady_clock::is_steady << '\n';
    std::cout << "system_clock::is_steady: " << system_clock::is_steady << '\n';
    std::cout << "high_resolution_clock::is_steady: " << high_resolution_clock::is_steady << '\n';
}

시간 측정 패턴

한 구간 측정: auto t0 = steady_clock::now(); … 작업 … auto dt = steady_clock::now() - t0;
내부 연산은 원래 duration 타입을 유지하고, 표시할 때만 duration_cast하는 편이 누적 오차를 줄이는 데 유리합니다.
여러 구간 누적: 구간마다 duration을 더하거나 time_point 차이를 합산합니다.
최소 오버헤드 측정: 아주 짧은 코드는 now() 두 번만으로도 수백 나노초가 나올 수 있어, 측정 대비 오버헤드를 빼거나(캘리브레이션), 반복 실행 후 평균·분위수를 쓰는 것이 일반적입니다.
sleep과 혼합: sleep_for는 “최소”만 보장하므로, 실제 경과는 항상 steady_clock으로 재는 것이 맞습니다.

auto t0 = std::chrono::steady_clock::now();
do_work();
auto t1 = std::chrono::steady_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(t1 - t0);

벤치마킹 활용

마이크로벤치에서는 다음을 함께 고려합니다.

워밍업: 캐시·할당기 상태가 첫 실행과 다를 수 있어, 몇 번 버린 뒤 측정합니다.
반복: 한 번보다 N회 평균·중앙값이 안정적입니다. 노이즈가 크면 고정밀 타이머 + 통계를 병행합니다.
최적화 방지: 컴파일러가 결과를 버리지 않게 벤치마크 라이브러리의 DoNotOptimize 패턴을 쓰기도 합니다(실무에서는 Google Benchmark 등 권장).
시계 선택: 경과 시간은 steady_clock. 결과를 “현재 시각”과 함께 로그에 남기려면 로그용으로만 system_clock을 쓰고, 측정 구간은 steady_clock으로 분리합니다.

위 파일의 benchmark 템플릿은 개념 설명용이며, 제품 코드에서는 외부 벤치마크 프레임워크와 프로파일러를 함께 쓰는 것이 좋습니다.

실전: 타임아웃 구현 (심화)

폴링 루프에서 타임아웃을 줄 때는 시작 시각 + 한도보다 deadline 시각을 두는 편이 읽기 쉽습니다.

#include <chrono>
#include <thread>

bool wait_until(std::chrono::steady_clock::time_point deadline,
                auto pred, std::chrono::milliseconds poll) {
    while (std::chrono::steady_clock::now() < deadline) {
        if (pred()) return true;
        std::this_thread::sleep_for(poll);
    }
    return false;
}

조건 변수·future: 스레드 동기화가 있으면 wait_for / wait_until이 CPU를 덜 쓰고 깨우기도 정확합니다. 폴링은 구현이 단순할 때만 사용합니다.
남은 시간: deadline - steady_clock::now()가 음수면 이미 만료입니다. duration_cast 전에 부호를 확인하거나 0으로 클램프합니다.

플랫폼별 차이

Linux: steady_clock은 보통 CLOCK_MONOTONIC 계열로, 시스템 시간 조정과 무관합니다. 해상도는 steady_clock::period로 확인합니다.
Windows: 구현은 MSVC/MinGW에 따라 다르지만, 표준 의미(단조 증가)는 동일하게 기대합니다. 고해상도 카운터를 쓰는 경우가 많습니다.
macOS/iOS: steady_clock은 일반적으로 단조 증가를 만족합니다. high_resolution_clock이 내부적으로 동일 시계를 가리키는 경우가 많습니다.
임베디드/RTOS: 틱 수가 낮으면 짧은 구간 측정에서 양자화 오차가 커질 수 있습니다. period::num/den과 실제 측정 오차를 한 번 확인하는 것이 좋습니다.
긴 가동 시간: 극단적으로 긴 업타임에서 카운터 비트 폭이 이론적 한계에 가까우면(드묾) 오버플로를 염두에 두되, 일반 데스크톱/서버에서는 duration 타입이 넉넉한 경우가 많습니다.

한 줄 요약: 절대 시각은 system_clock, 지속 시간과 타임아웃은 steady_clock, 이름만 보고 고르지 말고 high_resolution_clock의 is_steady와 구현 관계를 확인하세요.

FAQ

Q1: steady_clock은?

A: 단조 증가 시계.

Q2: system_clock과 차이?

steady: 단조 증가
system: 시스템 시간

Q3: 성능 측정?

A: steady_clock 권장.

Q4: 정밀도?

A: 플랫폼 의존. 나노초 수준.

Q5: 오버헤드?

A: 나노초 수준. 무시 가능.

Q6: steady_clock 학습 리소스는?

“C++ Primer”
“Effective Modern C++”
cppreference.com

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

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

심화 부록: 구현·운영 관점

이 부록은 앞선 본문에서 다룬 주제(「C++ steady_clock | ‘안정 시계’ 가이드」)를 구현·런타임·운영 관점에서 다시 압축합니다. 도메인별 세부 구현은 글마다 다르지만, 입력 검증 → 핵심 연산 → 부작용(I/O·네트워크·동시성) → 관측의 흐름으로 장애를 나누면 원인 추적이 빨라집니다.

내부 동작과 핵심 메커니즘

flowchart TD
  A[입력·요청·이벤트] --> B[파싱·검증·디코딩]
  B --> C[핵심 연산·상태 전이]
  C --> D[부작용: I/O·네트워크·동시성]
  D --> E[결과·관측·저장]

sequenceDiagram
  participant C as 클라이언트/호출자
  participant B as 경계(런타임·게이트웨이·프로세스)
  participant D as 의존성(API·DB·큐·파일)
  C->>B: 요청/이벤트
  B->>D: 조회·쓰기·RPC
  D-->>B: 지연·부분 실패·재시도 가능
  B-->>C: 응답 또는 오류(코드·상관 ID)

불변 조건(Invariant): 버퍼 경계, 프로토콜 상태, 트랜잭션 격리, FD 상한 등 단계별로 문장으로 적어 두면 디버깅 비용이 줄어듭니다.
결정성: 순수 층과 시간·네트워크·스케줄에 의존하는 층을 분리해야 테스트와 장애 분석이 쉬워집니다.
경계 비용: 직렬화, 인코딩, syscall 횟수, 락 경합, 할당·GC, 캐시 미스를 의심 목록에 둡니다.
백프레셔: 생산자가 소비자보다 빠를 때 버퍼·큐·스트림에서 속도를 줄이는 신호를 어디에 둘지 정의합니다.

프로덕션 운영 패턴

영역	운영 관점 질문
관측성	요청 단위 상관 ID, 에러율·지연 p95/p99, 의존성 타임아웃·재시도가 대시보드에 보이는가
안전성	입력 검증·권한·비밀·감사 로그가 코드 경로마다 일관적인가
신뢰성	재시도는 멱등 연산에만 적용되는가, 서킷 브레이커·백오프·DLQ가 있는가
성능	캐시·배치 크기·커넥션 풀·인덱스·백프레셔가 데이터 규모에 맞는가
배포	롤백 룬북, 카나리/블루그린, 마이그레이션·피처 플래그가 문서화되어 있는가
용량	피크 트래픽·디스크·FD·스레드 풀 상한을 주기적으로 검증하는가

스테이징은 데이터 양·네트워크 RTT·동시성을 프로덕션에 가깝게 맞출수록 재현율이 올라갑니다.

확장 예시: 엔드투엔드 미니 시나리오

앞선 본문 주제(「C++ steady_clock | ‘안정 시계’ 가이드」)를 배포·운영 흐름에 맞춰 옮긴 체크리스트입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.

입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드를 경계에 둔다.
핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 로그·메트릭·트레이스에서 한 흐름으로 본다.
실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지 확인한다.
부하 후 검증: 피크 대비 p95/p99, 에러율, 리소스 상한, 알림 임계값을 점검한다.

handle(request):
  ctx = newCorrelationId()
  validated = validateSchema(request)
  authorize(validated, ctx)
  result = domainCore(validated)
  persistOrEmit(result, idempotentKey)
  recordMetrics(ctx, latency, outcome)
  return result

문제 해결(Troubleshooting)

증상	가능 원인	조치
간헐적 실패	레이스, 타임아웃, 외부 의존성, DNS	최소 재현 스크립트, 분산 트레이스·로그 상관관계, 재시도·서킷 설정 점검
성능 저하	N+1, 동기 I/O, 락 경합, 과도한 직렬화, 캐시 미스	프로파일러·APM으로 핫스팟 확인 후 한 가지씩 제거
메모리 증가	캐시 무제한, 구독/리스너 누수, 대용량 버퍼, 커넥션 미반납	상한·TTL·힙/FD 스냅샷 비교
빌드·배포만 실패	환경 변수, 권한, 플랫폼 차이, lockfile	CI 로그와 로컬 diff, 런타임·이미지 버전 핀
설정 불일치	프로필·시크릿·기본값, 리전	스키마 검증된 설정 단일 소스와 배포 매트릭스 표준화
데이터 불일치	비멱등 재시도, 부분 쓰기, 캐시 무효화 누락	멱등 키·아웃박스·트랜잭션 경계 재검토

권장 순서: (1) 최소 재현 (2) 최근 변경 범위 축소 (3) 환경·의존성 차이 (4) 관측으로 가설 검증 (5) 수정 후 회귀·부하 테스트.

배포 전에는 git add → git commit → git push 후 npm run deploy 순서를 권장합니다.

이 글에서 다루는 키워드 (관련 검색어)

C++, steady_clock, chrono, benchmark, C++11 등으로 검색하시면 이 글이 도움이 됩니다.

이 글이 도움이 되셨나요?

여러분의 피드백은 더 나은 콘텐츠를 만드는 데 도움이 됩니다

문제가 있거나 개선 제안이 있으시면 연락처로 알려주세요.

Keyboard Shortcuts

C++ steady_clock | '안정 시계' 가이드

이 글의 핵심

steady_clock이란?

특징

실전 예시

예시 1: 벤치마크

예시 2: 타이머 클래스

예시 3: 타임아웃

예시 4: 성능 비교

system_clock vs steady_clock

자주 발생하는 문제

문제 1: 시계 선택

문제 2: 정밀도

문제 3: 오버헤드

문제 4: 긴 측정

활용 패턴

steady_clock vs system_clock vs high_resolution_clock

시간 측정 패턴

벤치마킹 활용

실전: 타임아웃 구현 (심화)

플랫폼별 차이

FAQ

Q1: steady_clock은?

Q2: system_clock과 차이?

Q3: 성능 측정?

Q4: 정밀도?

Q5: 오버헤드?

Q6: steady_clock 학습 리소스는?

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

관련 글

심화 부록: 구현·운영 관점

내부 동작과 핵심 메커니즘

프로덕션 운영 패턴

확장 예시: 엔드투엔드 미니 시나리오

문제 해결(Troubleshooting)

이 글에서 다루는 키워드 (관련 검색어)

이 글이 도움이 되셨나요?