동적 타이머 관리 및 조작 - 소프트웨어 융합

타이머의 동적 생성

Boost.Asio에서 제공하는 deadline_timer 클래스는 타이머를 관리하는 중요한 도구로, 이를 동적으로 생성하고 조작하는 것은 비동기 프로그래밍에서 필수적인 기술이다. 동적 타이머 관리는 프로그램 실행 중 여러 개의 타이머를 필요에 따라 생성하거나 소멸시키는 과정을 포함한다.

타이머는 특정 시간 이후에 특정 작업을 실행하는 비동기적 처리를 가능하게 하며, 이러한 타이머가 동적으로 생성되는 경우 다양한 상황에 대응할 수 있다. 특히, 다양한 시간 간격으로 다수의 작업을 처리해야 하는 시스템에서는 동적으로 타이머를 생성하고, 조건에 따라 타이머를 변경하거나 중지하는 것이 필요하다.

동적 타이머를 관리할 때 주의해야 할 점은 타이머의 생명 주기 관리이다. 즉, 타이머가 언제 시작하고 언제 종료될지를 결정하고, 만약 필요하지 않다면 타이머를 적절히 소멸시켜 자원을 효율적으로 사용하는 것이다.

동적 타이머 생성 예시

다음 예시는 동적 타이머를 생성하고, 이후에 해당 타이머를 기반으로 작업을 비동기로 처리하는 간단한 코드이다.

boost::asio::io_service io_service;
boost::asio::deadline_timer timer(io_service, boost::posix_time::seconds(5));

timer.async_wait([](const boost::system::error_code& error) {
    if (!error) {
        std::cout << "Timer expired!" << std::endl;
    }
});

io_service.run();

위 코드에서 타이머는 동적으로 생성되었으며, 5초 후에 비동기 작업이 실행된다. 동적으로 생성된 타이머는 async_wait을 통해 지정된 시간이 경과한 후에 비동기 콜백을 호출하는 구조로 되어 있다.

타이머의 상태 변경 및 재설정

동적 타이머는 필요에 따라 설정된 시간을 변경하거나 중간에 재설정할 수 있다. expires_at 또는 expires_from_now 메소드를 사용하여 타이머의 종료 시간을 수정할 수 있다.

$t_{\text{expires}} = t_{\text{now}} + \Delta t$

여기서:

$t_{\text{expires}}$ 는 타이머의 만료 시간
$t_{\text{now}}$ 는 현재 시간
$\Delta t$ 는 추가적으로 기다릴 시간

이 수식을 기반으로 타이머의 만료 시간을 설정하는 방식으로 동작한다.

다음은 타이머를 재설정하는 코드 예시이다.

timer.expires_from_now(boost::posix_time::seconds(10));

이 코드를 통해 타이머는 10초 후에 만료되도록 재설정된다. 타이머의 상태를 변경하는 경우, 이전에 설정된 대기 시간이 있더라도 이를 무시하고 새롭게 설정된 시간이 반영된다.

다중 타이머 관리

다수의 타이머를 관리하는 경우, 각 타이머가 독립적으로 동작하며 서로 다른 작업을 처리할 수 있다. 이러한 타이머들을 효율적으로 관리하기 위해서는 각 타이머에 고유한 핸들을 할당하고, 필요할 때마다 적절한 타이머를 참조할 수 있어야 한다.

다음은 여러 타이머를 관리하는 예시이다.

std::vector<std::shared_ptr<boost::asio::deadline_timer>> timers;
for (int i = 0; i < 5; ++i) {
    auto timer = std::make_shared<boost::asio::deadline_timer>(io_service, boost::posix_time::seconds(i+1));
    timer->async_wait([i](const boost::system::error_code& error) {
        if (!error) {
            std::cout << "Timer " << i << " expired!" << std::endl;
        }
    });
    timers.push_back(timer);
}

위 코드는 5개의 타이머를 동적으로 생성하고, 각 타이머가 순차적으로 만료되도록 한다. 이처럼 벡터 등을 활용하여 다수의 타이머를 관리하면 각각의 타이머를 독립적으로 제어할 수 있다.

타이머 취소 및 재사용

동적으로 생성된 타이머는 필요에 따라 취소하거나 재사용할 수 있다. 타이머를 취소하는 방법은 cancel 메소드를 사용하는 것이다. 타이머가 취소되면 해당 타이머와 연관된 비동기 작업은 호출되지 않으며, 이미 대기 중이던 작업은 취소 상태로 마무리된다.

타이머의 취소는 다음과 같은 수식으로 나타낼 수 있다.

$C_{\text{timer}} = 1 \implies \text{타이머 취소}$

여기서 $C_{\text{timer}}$ 는 타이머의 취소 상태를 나타내는 플래그이며, 값이 1이면 타이머가 취소된 상태임을 의미한다. 타이머가 취소되면 그와 관련된 비동기 작업은 더 이상 실행되지 않는다.

타이머 취소 예시는 다음과 같다.

boost::system::error_code ec;
timer.cancel(ec);
if (ec) {
    std::cout << "Error occurred during timer cancellation: " << ec.message() << std::endl;
}

위 코드에서 cancel 메소드는 타이머를 취소하며, 취소가 정상적으로 처리되지 않으면 에러 코드가 반환된다. 타이머를 취소한 후에도 해당 타이머 객체는 여전히 유효하며, 다시 설정해서 재사용할 수 있다.

타이머의 재사용

동일한 타이머 객체를 다시 사용하려면 expires_from_now를 통해 새로운 만료 시간을 설정한 후 async_wait을 호출하여 다시 비동기 대기를 설정할 수 있다. 이를 통해 타이머 객체를 재사용하는 비용을 줄일 수 있다.

timer.expires_from_now(boost::posix_time::seconds(15));
timer.async_wait([](const boost::system::error_code& error) {
    if (!error) {
        std::cout << "Timer expired after reconfiguration!" << std::endl;
    }
});

위 코드에서는 타이머를 재설정한 후 다시 비동기 작업을 설정하여 새로운 타이머 만료 시점을 기반으로 작업을 수행하도록 한다.

타이머의 비동기 작업 처리 시 고려사항

비동기 타이머는 특정 시간 후에 작업을 실행하는 방식이기 때문에, 대기 중인 시간 동안 다른 작업이 자유롭게 실행될 수 있어야 한다. 이를 위해 Boost.Asio는 이벤트 기반 비동기 모델을 제공하며, 모든 비동기 작업은 io_service 또는 io_context에서 관리된다.

이때, 타이머의 비동기 대기가 완료될 때까지의 시간 간격을 수식으로 나타내면 다음과 같다.

$T_{\text{wait}} = t_{\text{expires}} - t_{\text{now}}$

여기서:

$T_{\text{wait}}$ 는 대기 시간
$t_{\text{expires}}$ 는 타이머의 만료 시간
$t_{\text{now}}$ 는 현재 시간

비동기 작업이 여러 개 있을 때, 타이머가 만료되기 전에 다른 비동기 작업들이 병렬로 실행되거나 완료될 수 있다. 이는 타이머 만료와 상관없이 시스템이 유연하게 다른 작업들을 처리할 수 있도록 한다.

타이머와 다중 스레드 환경

동적 타이머를 다중 스레드 환경에서 관리할 때는 주의가 필요하다. 각 스레드가 별도의 타이머를 처리하거나, 동일한 타이머를 여러 스레드에서 접근하는 상황이 발생할 수 있기 때문이다. Boost.Asio는 기본적으로 스레드 안전하지 않기 때문에, 여러 스레드에서 타이머 객체를 공유하려면 적절한 동기화가 필요하다.

예를 들어, 다음과 같이 여러 스레드에서 타이머를 동시에 사용할 수 있다.

boost::asio::io_service io_service;
boost::asio::deadline_timer timer(io_service, boost::posix_time::seconds(10));

std::thread t1([&io_service]() {
    io_service.run();
});

std::thread t2([&io_service]() {
    io_service.run();
});

timer.async_wait([](const boost::system::error_code& error) {
    if (!error) {
        std::cout << "Timer expired in multithreaded context!" << std::endl;
    }
});

t1.join();
t2.join();

이 코드에서는 두 개의 스레드가 동일한 io_service를 공유하여 타이머 작업을 처리한다. io_service는 스레드 간에 안전하게 공유되지만, 타이머 자체는 안전하지 않기 때문에 스레드 간에 타이머를 직접적으로 접근할 때는 동기화가 필요하다.

타이머의 동적 조작과 콜백 관리

동적 타이머 관리에서 중요한 또 하나의 측면은 타이머에 연결된 콜백 함수의 관리이다. 타이머는 비동기적으로 작업을 수행하는 도구이므로, 타이머가 만료되었을 때 실행할 작업을 콜백 함수로 설정해야 한다. 이때 콜백 함수는 타이머의 상태나 특정 조건에 따라 동적으로 변경하거나 조정할 수 있다.

콜백 함수의 동적 변경

타이머에 연결된 콜백 함수는 비동기 작업이 완료될 때 호출된다. 그러나 타이머가 동적으로 변경되는 경우, 콜백 함수도 이에 따라 동적으로 변경해야 할 수 있다. 예를 들어, 타이머 만료 시점에 따라 다른 작업을 수행하거나, 특정 조건이 충족될 때 다른 콜백을 실행하도록 할 수 있다.

다음은 콜백을 동적으로 변경하는 코드의 예시이다.

void first_callback(const boost::system::error_code& error) {
    if (!error) {
        std::cout << "First callback executed!" << std::endl;
    }
}

void second_callback(const boost::system::error_code& error) {
    if (!error) {
        std::cout << "Second callback executed!" << std::endl;
    }
}

boost::asio::deadline_timer timer(io_service, boost::posix_time::seconds(5));
timer.async_wait(first_callback);

// 타이머가 실행되기 전에 콜백을 변경
timer.expires_from_now(boost::posix_time::seconds(10));
timer.async_wait(second_callback);

위 코드에서 처음에는 first_callback이 설정되어 있었지만, 타이머 만료 시간이 변경되면서 second_callback으로 변경되었다. 타이머는 재설정된 시간에 따라 새로운 콜백 함수를 호출한다.

콜백 함수의 상태 관리

타이머의 콜백 함수에서 시스템 상태나 타이머의 만료 시간을 동적으로 변경할 수 있다. 예를 들어, 타이머가 반복적으로 실행되도록 하고, 콜백 함수 내부에서 타이머를 다시 시작하도록 할 수 있다.

이를 표현하는 수식은 다음과 같다.

$T_{\text{next}} = T_{\text{current}} + \Delta T$

여기서 $T_{\text{next}}$ 는 다음 타이머의 만료 시간이고, $\Delta T$ 는 현재 타이머 만료 후의 추가 대기 시간이다. 이러한 방식으로 타이머는 콜백 내에서 동적으로 재설정되며, 주기적인 작업을 수행할 수 있다.

void repeat_callback(const boost::system::error_code& error, boost::asio::deadline_timer& timer) {
    if (!error) {
        std::cout << "Timer expired, repeating..." << std::endl;
        timer.expires_from_now(boost::posix_time::seconds(5));
        timer.async_wait(std::bind(repeat_callback, std::placeholders::_1, std::ref(timer)));
    }
}

위 코드에서 타이머는 만료될 때마다 5초 후에 다시 설정되며, 반복적으로 작업을 수행하게 된다. 이와 같이 콜백 함수 내부에서 타이머를 동적으로 제어함으로써, 주기적인 작업을 간편하게 처리할 수 있다.

타이머의 정확성 및 성능 고려

타이머를 비동기적으로 사용하면서 중요한 것은 타이머의 정확성이다. Boost.Asio에서 제공하는 타이머는 높은 정밀도로 시간을 측정하지만, 시스템의 부하 상태나 타이머 재설정 시점에 따라 정확도가 떨어질 수 있다. 특히, 다중 타이머를 관리할 때는 시스템의 자원을 효율적으로 사용하는 것이 성능에 큰 영향을 미친다.

$E_{\text{timer}} = T_{\text{actual}} - T_{\text{expected}}$

여기서 $E_{\text{timer}}$ 는 타이머의 오차, $T_{\text{actual}}$ 은 실제 타이머가 만료된 시간, $T_{\text{expected}}$ 는 예상된 만료 시간을 의미한다. 이 오차가 발생하는 주된 이유는 타이머가 이벤트 큐에 추가되고 실행되는 동안의 시스템 상태 때문이다.

타이머의 정확성을 보장하기 위한 전략

타이머의 정확성을 높이기 위해 사용할 수 있는 몇 가지 전략은 다음과 같다.

높은 우선순위 설정: 타이머가 만료되었을 때 즉시 콜백이 실행될 수 있도록 타이머의 우선순위를 높이는 것이다. 이를 위해 io_service의 스레드 수를 증가시켜 비동기 작업이 신속히 처리되도록 할 수 있다.
타이머 재설정 시점 최적화: 타이머가 만료되기 직전에 재설정하는 것이 아니라, 적절한 시점에서 타이머를 미리 설정하여 시스템이 타이머 작업을 빠르게 인식하도록 해야 한다.
정확한 시간 측정 도구 사용: Boost.Asio는 steady_timer를 제공하여 시스템 클럭에 의존하지 않고 상대적으로 정확한 시간 기반 타이머를 구현할 수 있다.

boost::asio::steady_timer steady_timer(io_service, boost::asio::chrono::seconds(5));
steady_timer.async_wait([](const boost::system::error_code& error) {
    if (!error) {
        std::cout << "Steady timer expired with high precision!" << std::endl;
    }
});

steady_timer는 시스템의 시간 변동에 영향을 받지 않고 상대적으로 정확한 시간 측정을 제공하므로, 특정 시간 간격을 정확하게 유지해야 하는 작업에 적합하다.

타이머의 상태 확인 및 예외 처리

동적 타이머 관리에서 타이머의 상태를 실시간으로 확인하고, 예외가 발생할 경우 이를 처리하는 것은 중요한 부분이다. 타이머가 정상적으로 만료되었는지, 아니면 취소되었는지 등을 정확히 파악해야 하며, 발생할 수 있는 다양한 에러 상황에 적절히 대응해야 한다.

타이머의 상태 확인

타이머의 상태를 확인하는 방법 중 하나는 비동기 작업에서 전달되는 boost::system::error_code 객체를 이용하는 것이다. 타이머가 성공적으로 만료되었는지, 취소되었는지, 혹은 에러가 발생했는지를 확인할 수 있다.

타이머의 상태는 다음과 같은 수식으로 표현할 수 있다.

$S_{\text{timer}} = \begin{cases} 0, & \text{정상 만료} \\ 1, & \text{취소됨} \\ 2, & \text{에러 발생} \end{cases}$

여기서 $S_{\text{timer}}$ 는 타이머의 상태를 나타내며, 정상적으로 만료되었을 경우 0, 취소되었을 경우 1, 에러가 발생했을 경우 2로 나타낸다.

예를 들어, 아래 코드에서는 타이머의 상태를 확인하여 처리하는 과정을 보여준다.

void timer_callback(const boost::system::error_code& error) {
    if (!error) {
        std::cout << "Timer expired normally!" << std::endl;
    } else if (error == boost::asio::error::operation_aborted) {
        std::cout << "Timer was cancelled." << std::endl;
    } else {
        std::cout << "An error occurred: " << error.message() << std::endl;
    }
}

예외 처리

Boost.Asio에서 타이머를 사용할 때 발생할 수 있는 예외는 주로 시스템 에러에 기인한다. 대표적으로 다음과 같은 상황에서 예외가 발생할 수 있다.

타이머 취소: 타이머가 외부에서 취소된 경우, 이는 boost::asio::error::operation_aborted로 처리된다.
시스템 리소스 부족: 타이머가 생성되었으나 시스템 리소스가 부족하여 제대로 실행되지 못한 경우, boost::system::system_error가 발생할 수 있다.

이러한 예외는 비동기 콜백 함수 내에서 적절히 처리해야 한다.

try {
    boost::asio::deadline_timer timer(io_service, boost::posix_time::seconds(5));
    timer.async_wait(timer_callback);
    io_service.run();
} catch (const boost::system::system_error& e) {
    std::cerr << "System error: " << e.what() << std::endl;
}

위 코드는 타이머 사용 중 발생할 수 있는 시스템 예외를 처리하는 예시이다. try-catch 블록을 사용하여 예외 발생 시 적절한 대응을 할 수 있다.

타이머의 동기와 비동기 사용 비교

Boost.Asio에서는 타이머를 동기적으로 사용할 수 있으며, 이 경우 타이머가 만료될 때까지 현재 스레드는 대기 상태가 된다. 비동기적으로 사용할 때와의 차이를 비교해 보자.

동기 타이머

동기 타이머는 wait() 메소드를 사용하여 타이머가 만료될 때까지 스레드를 블록(block)시킨다. 이는 수식으로 다음과 같이 표현될 수 있다.

$T_{\text{block}} = t_{\text{expires}} - t_{\text{now}}$

여기서 $T_{\text{block}}$ 는 블록된 시간이며, 타이머가 만료될 때까지 현재 스레드가 블록된 시간을 의미한다.

boost::asio::deadline_timer timer(io_service, boost::posix_time::seconds(5));
timer.wait();
std::cout << "Timer expired synchronously!" << std::endl;

위 코드에서는 타이머가 동기적으로 실행되며, 5초 동안 스레드가 블록된 상태로 유지된다.

비동기 타이머

비동기 타이머는 async_wait() 메소드를 통해 스레드를 블록시키지 않고, 타이머가 만료되었을 때만 콜백 함수가 호출된다. 이 방식은 비동기적으로 다른 작업을 동시에 처리하는 데 유리하다.

boost::asio::deadline_timer timer(io_service, boost::posix_time::seconds(5));
timer.async_wait([](const boost::system::error_code& error) {
    if (!error) {
        std::cout << "Timer expired asynchronously!" << std::endl;
    }
});
io_service.run();

위 코드는 비동기 타이머를 사용한 예시이며, 타이머가 만료될 때까지 다른 작업이 자유롭게 실행될 수 있다.

동기와 비동기의 장단점

특징	동기 타이머	비동기 타이머
스레드 상태	타이머 만료 시까지 블록됨	블록되지 않음, 다른 작업과 병행 가능
자원 사용	단일 스레드에서 간단히 사용 가능	다중 작업이 동시에 실행될 때 더 유리
코드 복잡도	단순	콜백 함수 또는 이벤트 핸들러 관리 필요
성능	제한된 자원 사용 시 적합	고성능 비동기 시스템에 적합

동기 타이머는 간단한 프로그램에서 적합하지만, 비동기 타이머는 더 복잡하고 높은 성능을 요구하는 상황에 적합하다.

타이머의 대기 중단 및 재시작

Boost.Asio 타이머는 중간에 대기를 중단하거나 다시 시작할 수 있다. 타이머 대기 중단은 타이머가 특정 시간 전에 취소되는 경우로, 이를 통해 타이머의 대기 시간을 유동적으로 관리할 수 있다. 대기 중단과 재시작은 시스템의 요구 사항에 따라 적절히 조정하여 성능을 최적화하는 데 도움을 줄 수 있다.

타이머 대기 중단

타이머 대기를 중단하는 가장 간단한 방법은 cancel() 메소드를 사용하는 것이다. cancel()은 타이머의 대기를 중지하고, 타이머에 등록된 비동기 작업을 취소한다. 이렇게 취소된 타이머는 더 이상 대기하지 않으며, 그에 따른 콜백 함수도 호출되지 않는다.

타이머의 대기 중단을 수식으로 표현하면 다음과 같다.

$C_{\text{wait}} = 1 \implies T_{\text{remaining}} = 0$

여기서:

$C_{\text{wait}}$ 는 타이머의 대기 중단 플래그
$T_{\text{remaining}}$ 은 남은 대기 시간, 대기가 취소되면 0이 된다

다음은 타이머 대기 중단의 코드 예시이다.

boost::asio::deadline_timer timer(io_service, boost::posix_time::seconds(10));
timer.async_wait([](const boost::system::error_code& error) {
    if (!error) {
        std::cout << "Timer expired normally." << std::endl;
    } else {
        std::cout << "Timer was cancelled." << std::endl;
    }
});

boost::system::error_code ec;
timer.cancel(ec);  // 타이머 대기 중단
io_service.run();

위 코드에서 타이머는 10초 동안 대기하지만, cancel()이 호출됨으로써 대기 중단 상태가 되고 타이머의 콜백 함수는 더 이상 정상적으로 실행되지 않는다. 콜백 함수 내부에서 에러 코드를 통해 타이머가 취소되었음을 확인할 수 있다.

타이머 재시작

타이머를 대기 중단한 후 다시 대기 상태로 전환하려면 타이머의 만료 시간을 재설정하고, 비동기 대기를 다시 설정해야 한다. expires_from_now() 또는 expires_at() 메소드를 통해 새로운 만료 시간을 설정한 뒤 async_wait()을 호출하여 타이머를 재시작할 수 있다.

타이머의 재시작을 수식으로 표현하면 다음과 같다.

$T_{\text{new}} = t_{\text{now}} + \Delta t$

여기서 $T_{\text{new}}$ 는 새로운 타이머의 만료 시간이며, $\Delta t$ 는 추가적으로 대기할 시간을 의미한다.

다음은 타이머를 취소한 후 다시 재시작하는 코드 예시이다.

boost::asio::deadline_timer timer(io_service, boost::posix_time::seconds(10));
timer.async_wait([](const boost::system::error_code& error) {
    if (!error) {
        std::cout << "Timer expired normally." << std::endl;
    } else {
        std::cout << "Timer was cancelled." << std::endl;
    }
});

// 타이머 취소
boost::system::error_code ec;
timer.cancel(ec);

// 타이머 재시작
timer.expires_from_now(boost::posix_time::seconds(5));
timer.async_wait([](const boost::system::error_code& error) {
    if (!error) {
        std::cout << "Timer expired after restart." << std::endl;
    }
});

io_service.run();

위 코드에서는 타이머가 처음에는 10초 동안 설정되었지만, 대기 중단 후 5초로 재설정되어 다시 시작된다. 이는 타이머를 동적으로 관리하여 필요에 따라 대기 시간을 변경하거나 취소할 수 있음을 보여준다.

타이머를 활용한 비동기 반복 작업

타이머를 사용하여 비동기 반복 작업을 구현하는 것은 매우 일반적인 패턴이다. 타이머가 주기적으로 만료될 때마다 특정 작업을 반복적으로 수행하도록 설정할 수 있으며, 이를 통해 주기적인 작업을 비동기적으로 처리할 수 있다. 이 방법은 주로 서버 애플리케이션에서 상태 점검, 정기적 데이터 수집 등의 작업에 유용하다.

타이머를 활용한 반복 작업은 다음과 같은 수식으로 나타낼 수 있다.

$T_{\text{next}} = T_{\text{current}} + \Delta t$

여기서:

$T_{\text{next}}$ 는 다음 작업이 수행될 시간
$T_{\text{current}}$ 는 현재 타이머 만료 시간
$\Delta t$ 는 주기적인 대기 시간

반복 타이머 구현 예시

다음은 비동기 타이머를 사용하여 주기적인 작업을 처리하는 코드이다.

void periodic_task(boost::asio::deadline_timer& timer, int interval) {
    std::cout << "Task executed!" << std::endl;

    // 타이머 재설정 및 다시 대기
    timer.expires_from_now(boost::posix_time::seconds(interval));
    timer.async_wait([&timer, interval](const boost::system::error_code& error) {
        if (!error) {
            periodic_task(timer, interval);
        }
    });
}

boost::asio::io_service io_service;
boost::asio::deadline_timer timer(io_service, boost::posix_time::seconds(2));

timer.async_wait([&timer](const boost::system::error_code& error) {
    if (!error) {
        periodic_task(timer, 2);  // 2초마다 작업 반복
    }
});

io_service.run();

위 코드에서 periodic_task 함수는 2초마다 반복적으로 호출된다. 타이머는 매번 만료될 때마다 새로운 대기 시간을 설정하고, 비동기적으로 대기 작업을 수행한다.

다중 타이머를 통한 복합 작업 스케줄링

여러 개의 타이머를 동시에 사용하여 복합 작업을 스케줄링할 수도 있다. 이를 통해 서로 다른 주기나 시점에 실행되는 여러 작업을 비동기적으로 처리할 수 있다. 이러한 방식은 비동기 네트워크 서버나 복잡한 타이밍 요구 사항을 갖는 애플리케이션에서 유용하다.

다중 타이머를 활용할 때의 시간 관리 방정식은 다음과 같다.

$T_{\text{task}_i} = t_{\text{now}} + \Delta t_i$

여기서:

$T_{\text{task}_i}$ 는 i번째 작업의 만료 시간
$\Delta t_i$ 는 i번째 타이머의 대기 시간

다중 타이머 관리 예시

다음 코드는 여러 타이머를 동시에 사용하여 복합적인 작업을 처리하는 예시이다.

boost::asio::io_service io_service;
boost::asio::deadline_timer timer1(io_service, boost::posix_time::seconds(3));
boost::asio::deadline_timer timer2(io_service, boost::posix_time::seconds(5));

timer1.async_wait([](const boost::system::error_code& error) {
    if (!error) {
        std::cout << "Timer 1 expired after 3 seconds." << std::endl;
    }
});

timer2.async_wait([](const boost::system::error_code& error) {
    if (!error) {
        std::cout << "Timer 2 expired after 5 seconds." << std::endl;
    }
});

io_service.run();

이 코드에서는 두 개의 타이머가 각각 3초와 5초 후에 만료되며, 서로 다른 시점에 콜백 함수가 실행된다. 이처럼 다중 타이머를 사용하면 동시에 다양한 작업을 독립적으로 스케줄링할 수 있다.