Strand를 통한 동기화 - 실험 도서관

Boost.Asio에서 strand는 비동기 작업의 동기화를 간단하고 효율적으로 처리하기 위한 도구이다. 여러 개의 비동기 작업이 서로 간섭하지 않도록 하기 위해서는 특정 자원에 대한 접근을 직렬화해야 할 때가 있다. strand는 이를 달성하는 메커니즘으로, 여러 개의 작업이 있을 때 이들을 순차적으로 처리되도록 보장한다.

비동기 프로그래밍에서는 여러 작업이 동시에 실행될 수 있는 환경에서 자원 경쟁이 발생할 수 있다. 예를 들어, 두 개 이상의 작업이 동일한 메모리 자원에 접근하게 되면, 프로그램이 잘못된 상태에 도달할 수 있다. 이러한 상황을 해결하기 위해 전통적으로는 뮤텍스(mutex)나 락(lock)과 같은 동기화 기법을 사용하지만, 이러한 기법들은 코드 복잡성을 증가시키고, 성능에 부정적인 영향을 미칠 수 있다. Boost.Asio의 strand는 이러한 문제를 해결하기 위한 더 나은 방법을 제공한다.

Strand의 기본 개념

Boost.Asio에서 strand는 특정 컨텍스트 내에서 작업들이 직렬화되어 실행되도록 보장하는 방법이다. 즉, strand를 사용하여 묶인 작업들은 동시에 실행되지 않으며, 반드시 하나의 작업이 완료된 후에 다른 작업이 시작된다. 이를 통해 특정 자원에 대해 동기화를 쉽게 할 수 있다.

다음은 기본적인 사용 흐름이다:

strand 객체를 생성한다.
비동기 작업을 strand에 바인딩하여 실행한다.
Boost.Asio의 io_context는 strand에 바인딩된 작업을 직렬화하여 처리한다.

이를 통해 각 작업이 순차적으로 실행되므로, 작업 간의 자원 경쟁이 발생하지 않게 된다.

Strand의 작동 원리

Boost.Asio의 strand는 작업을 내부적으로 큐(queue)에 넣고, 이를 io_context에서 순차적으로 실행하도록 한다. 이때, 한 작업이 실행되는 동안 동일한 strand에 바인딩된 다른 작업은 대기 상태가 되며, 작업이 완료되면 다음 작업이 실행된다. 이를 통해 비동기 작업 간의 충돌을 방지할 수 있다.

다음은 Boost.Asio에서 strand를 사용하는 예시이다:

boost::asio::io_context io_context;
boost::asio::strand<boost::asio::io_context::executor_type> strand(io_context.get_executor());

io_context.post(strand.wrap([](){ std::cout << "첫 번째 작업" << std::endl; }));
io_context.post(strand.wrap([](){ std::cout << "두 번째 작업" << std::endl; }));

io_context.run();

위 코드에서 strand.wrap()을 통해 비동기 작업이 strand에 바인딩되고, 이로 인해 "첫 번째 작업"과 "두 번째 작업"은 순차적으로 실행된다.

Strand의 수학적 모델

이 문제를 수학적으로 표현하기 위해, 두 가지 작업 $\mathbf{A}$ 와 $\mathbf{B}$ 가 존재한다고 가정하자. 이 두 작업이 동일한 자원 $\mathbf{R}$ 에 접근해야 한다고 할 때, strand가 없는 상태에서는 두 작업이 다음과 같이 실행될 가능성이 있다:

$\mathbf{T_A} = f(\mathbf{R})$

$\mathbf{T_B} = g(\mathbf{R})$

이때, $\mathbf{T_A}$ 와 $\mathbf{T_B}$ 는 병렬로 실행될 수 있으며, 자원 $\mathbf{R}$ 에 대한 접근이 중복될 수 있다. 그러나 strand를 사용하면 이 두 작업이 반드시 순차적으로 실행되므로, 아래와 같은 순서를 보장할 수 있다:

$\mathbf{T_A} \rightarrow \mathbf{T_B} \quad \text{또는} \quad \mathbf{T_B} \rightarrow \mathbf{T_A}$

따라서 자원 $\mathbf{R}$ 에 대한 충돌이 발생하지 않으며, 각 작업은 순차적으로 실행된다.

Strand와 멀티스레드 환경

Boost.Asio의 strand는 주로 멀티스레드 환경에서의 비동기 작업 동기화를 위해 사용된다. 단일 스레드 환경에서는 각 비동기 작업이 순차적으로 실행되기 때문에 strand의 필요성이 적지만, 멀티스레드 환경에서는 여러 스레드가 동시에 실행되기 때문에 자원 경합이나 데이터 레이스의 가능성이 높아진다. 이때 strand는 각 스레드에서 발생하는 비동기 작업들이 직렬화되어 실행되도록 보장한다.

멀티스레드 환경에서 strand의 작동 방식을 이해하기 위해, $N$ 개의 스레드가 실행 중이라고 가정하자. 각 스레드에서 작업 $\mathbf{T_1}, \mathbf{T_2}, \dots, \mathbf{T_n}$ 이 발생한다고 할 때, 각 작업이 strand에 바인딩되어 있다면, 해당 strand에 바인딩된 작업들은 여러 스레드에 의해 동시에 실행되지 않고, 특정 순서로 실행된다.

이 동작을 수식으로 표현하면, strand에 바인딩된 작업들의 실행 순서는 다음과 같이 정의된다:

$\mathbf{T_1}, \mathbf{T_2}, \dots, \mathbf{T_n} \quad \text{such that} \quad \mathbf{T_1} \rightarrow \mathbf{T_2} \rightarrow \dots \rightarrow \mathbf{T_n}$

즉, 여러 스레드가 동시에 실행 중이더라도 strand에 바인딩된 작업들끼리는 직렬화된 순서를 유지하며 실행된다. 이를 통해 자원 충돌을 방지할 수 있다.

Strand를 이용한 작업 디스패칭

Boost.Asio에서 strand를 사용한 작업 디스패칭은 두 가지 방식으로 이루어진다:

post: post는 비동기 작업을 즉시 실행 큐에 추가하여 가능한 빨리 실행되도록 한다. post로 전달된 작업은 순차적으로 실행된다.
dispatch: dispatch는 현재 스레드에서 작업을 즉시 실행할 수 있을 때 실행하고, 그렇지 않으면 실행 큐에 추가한다. 즉, dispatch는 호출된 시점에서 바로 실행 가능하면 실행하고, 그렇지 않으면 다음으로 미룬다.

이 두 가지 방법 모두 strand를 사용하여 동기화를 보장하지만, 사용되는 상황에 따라 선택적으로 사용할 수 있다.

다음은 post와 dispatch의 사용 예시이다:

boost::asio::strand<boost::asio::io_context::executor_type> strand(io_context.get_executor());

// post: 가능한 빨리 실행되도록 큐에 작업 추가
io_context.post(strand.wrap([](){ std::cout << "post로 실행된 작업" << std::endl; }));

// dispatch: 현재 스레드에서 즉시 실행할 수 있으면 실행
io_context.dispatch(strand.wrap([](){ std::cout << "dispatch로 실행된 작업" << std::endl; }));

Strand와 자원 경쟁 문제 해결

멀티스레드 환경에서는 여러 스레드가 동일한 자원에 접근할 때 자원 경쟁 문제가 발생할 수 있다. 이를 해결하기 위해 뮤텍스나 락을 사용하는 대신, Boost.Asio의 strand는 더 간단하고 직관적인 방법으로 자원에 대한 순차적인 접근을 보장한다.

예를 들어, 두 개의 스레드가 동일한 변수 $\mathbf{X}$ 에 접근한다고 가정하자. 만약 이 두 스레드가 strand를 사용하지 않고 각각 비동기 작업을 실행하면, 아래와 같은 경쟁 상태가 발생할 수 있다:

$\mathbf{X} = \mathbf{X} + 1$

각 스레드는 동일한 변수 $\mathbf{X}$ 에 접근하며, 병렬로 실행될 경우 결과가 일관되지 않게 될 수 있다. 하지만, 두 스레드 모두 strand를 사용하여 해당 작업을 직렬화하면, 작업들이 순차적으로 실행되므로 자원에 대한 경쟁을 피할 수 있다. 따라서 결과는 항상 올바르게 유지된다.

int X = 0;
boost::asio::strand<boost::asio::io_context::executor_type> strand(io_context.get_executor());

// 두 개의 스레드에서 동일한 변수에 접근하는 비동기 작업
io_context.post(strand.wrap([&X](){ X += 1; }));
io_context.post(strand.wrap([&X](){ X += 1; }));

// io_context가 모든 작업을 순차적으로 실행
io_context.run();

위 코드를 통해 strand를 사용하면, 두 개의 작업이 같은 자원에 접근할 때 경쟁 상태를 피하고, 항상 올바른 결과를 얻을 수 있다.

Strand와 비동기 핸들러의 결합

Boost.Asio에서 strand를 사용하는 주요 이유 중 하나는 비동기 핸들러들이 자원에 안전하게 접근할 수 있도록 하기 위함이다. 일반적으로 비동기 핸들러는 비동기 작업이 완료된 후 호출되는데, 만약 핸들러가 자원에 접근해야 하거나, 여러 핸들러가 동일한 자원을 처리해야 하는 경우에는 반드시 동기화가 필요하다. 이를 위해 Boost.Asio는 핸들러와 strand를 결합하여 자원 접근을 직렬화할 수 있는 메커니즘을 제공한다.

핸들러는 비동기 작업의 결과를 처리하는 함수로, strand에 바인딩된 핸들러는 strand를 사용해 비동기 작업이 순차적으로 실행되도록 한다. 다음과 같은 예시를 통해 비동기 핸들러와 strand의 결합을 확인할 수 있다:

boost::asio::strand<boost::asio::io_context::executor_type> strand(io_context.get_executor());

auto handler = [&](){
    std::cout << "비동기 핸들러 실행" << std::endl;
};

// 핸들러를 strand에 바인딩하여 안전하게 실행
boost::asio::post(strand.wrap(handler));

위 코드에서 strand.wrap(handler)는 핸들러를 strand와 결합하여 실행하는 방식이다. 이 결합된 핸들러는 다른 strand 작업들과 직렬화되어 실행된다. 이는 핸들러가 여러 비동기 작업 중 자원에 안전하게 접근할 수 있도록 보장한다.

핸들러 바인딩의 수학적 표현

비동기 핸들러를 strand에 바인딩하는 것은 자원 접근의 순차성을 수학적으로 보장하는 모델로 이해할 수 있다. 여러 개의 핸들러 $\mathbf{H_1}, \mathbf{H_2}, \dots, \mathbf{H_n}$ 가 존재한다고 할 때, 각 핸들러가 특정 자원 $\mathbf{R}$ 에 접근한다고 가정하자.

strand가 없는 상태에서 비동기 핸들러들은 병렬로 실행될 수 있으며, 이는 자원 $\mathbf{R}$ 에 대한 접근 순서를 보장하지 않는다. 하지만 핸들러들을 strand에 바인딩하면, 각 핸들러는 반드시 순차적으로 실행되며, 자원 접근 충돌을 피할 수 있다. 이를 수식으로 표현하면 다음과 같다:

$\mathbf{H_1}(R) \rightarrow \mathbf{H_2}(R) \rightarrow \dots \rightarrow \mathbf{H_n}(R)$

따라서 핸들러들은 $\mathbf{R}$ 에 대해 동시에 접근하지 않고, 순차적으로 실행되기 때문에 자원의 무결성을 유지할 수 있다.

여러 Strand를 사용한 동시성 제어

하나의 strand만으로 모든 작업을 직렬화할 수도 있지만, 더 복잡한 애플리케이션에서는 여러 개의 strand를 사용할 수 있다. 각 strand는 자신에게 할당된 비동기 작업만 직렬화하므로, 특정 자원에 대한 직렬화가 필요한 경우에만 strand를 사용할 수 있다. 이를 통해 시스템 전체의 동시성을 높이면서도, 중요한 자원에 대한 동기화는 유지할 수 있다.

다음은 두 개의 strand를 사용하여 두 개의 자원에 대한 동기화를 각각 따로 적용하는 예시이다:

boost::asio::strand<boost::asio::io_context::executor_type> strand1(io_context.get_executor());
boost::asio::strand<boost::asio::io_context::executor_type> strand2(io_context.get_executor());

int resource1 = 0;
int resource2 = 0;

// resource1에 대한 작업은 strand1을 통해 직렬화
io_context.post(strand1.wrap([&resource1](){ resource1 += 1; }));

// resource2에 대한 작업은 strand2을 통해 직렬화
io_context.post(strand2.wrap([&resource2](){ resource2 += 1; }));

io_context.run();

위 코드에서 두 개의 자원 resource1과 resource2는 각각 다른 strand를 사용하여 관리된다. strand1은 resource1에 대한 작업을 직렬화하고, strand2는 resource2에 대한 작업을 직렬화한다. 이로 인해 두 자원에 대한 작업은 서로 독립적으로 실행되며, 각 자원에 대해 동시성이 높아진다.

수학적으로 이는 두 개의 자원 $\mathbf{R_1}$ 과 $\mathbf{R_2}$ 가 각각의 strand에 할당되었을 때, 두 자원에 대한 접근이 순차적으로 이루어짐을 보장한다:

$\mathbf{T_1}(R_1) \rightarrow \mathbf{T_2}(R_1) \quad \text{and} \quad \mathbf{T_3}(R_2) \rightarrow \mathbf{T_4}(R_2)$

이때, $\mathbf{T_1}$ 과 $\mathbf{T_3}$ 는 병렬로 실행될 수 있으며, 각 자원에 대한 작업은 서로 간섭하지 않는다.

Strand와 멀티스레드의 성능 향상

비동기 프로그래밍에서 자원을 보호하기 위해서 뮤텍스나 락과 같은 전통적인 동기화 방법을 사용할 경우, 각 스레드가 락을 해제할 때까지 대기해야 하는 비용이 발생한다. 이로 인해 프로그램의 성능이 크게 저하될 수 있다. 하지만 Boost.Asio의 strand는 각 작업을 큐에 넣고 순차적으로 처리하기 때문에 락을 사용하지 않고도 안전하게 자원에 접근할 수 있다. 이는 특히 고성능 멀티스레드 애플리케이션에서 큰 이점을 제공한다.

strand를 통해 작업을 직렬화하면, 락 대기 시간을 줄이고, CPU가 더 효율적으로 사용될 수 있다. 그 결과, 멀티스레드 환경에서도 자원에 대한 접근이 보다 효율적으로 이루어진다.

Strand와 io_context의 관계

Boost.Asio에서 strand는 io_context와 밀접하게 연관되어 작동한다. io_context는 비동기 작업을 처리하는 중추적인 역할을 하며, strand는 이 io_context의 실행 맥락 안에서 동작한다. io_context는 작업들을 큐에 추가하고 스레드 풀에서 작업들을 실행하는데, strand는 이를 조정하여 특정 작업들 간에 순차적인 실행을 보장한다.

io_context와 strand의 상호작용

Boost.Asio에서 io_context는 여러 개의 작업을 동시에 처리할 수 있는 작업 큐를 제공한다. io_context는 기본적으로 여러 스레드를 관리하며, 각 스레드는 비동기 작업을 비동기로 처리한다. 이때, strand를 사용하면 io_context에 추가된 작업들 중에서 특정 작업 그룹은 순차적으로 실행되도록 보장할 수 있다.

다음과 같은 코드에서 io_context와 strand의 관계를 볼 수 있다:

boost::asio::io_context io_context;
boost::asio::strand<boost::asio::io_context::executor_type> strand(io_context.get_executor());

// io_context는 여러 비동기 작업을 관리하고 실행
io_context.post(strand.wrap([](){ std::cout << "첫 번째 작업" << std::endl; }));
io_context.post(strand.wrap([](){ std::cout << "두 번째 작업" << std::endl; }));

// io_context.run()을 호출하면 strand에 의해 순차적으로 실행됨
io_context.run();

이 예시에서 io_context는 여러 개의 작업을 동시에 처리할 수 있지만, strand에 의해 묶인 작업들은 반드시 순차적으로 실행된다. io_context는 strand가 적용된 작업들을 하나씩 큐에서 꺼내어 순차적으로 처리하게 된다.

io_context 스레드 풀과 strand의 조합

io_context는 여러 개의 스레드를 통해 병렬 작업을 처리할 수 있다. 하지만 strand를 사용하면 각 스레드에서 동시에 실행되는 작업들 사이에서도 특정 순서를 보장할 수 있다. 즉, 여러 스레드에서 strand가 적용된 작업들이 동시에 발생하더라도, strand는 각 작업이 순차적으로 실행되도록 보장한다.

멀티스레드 환경에서 io_context와 strand의 상호작용은 다음과 같은 방식으로 이루어진다:

io_context는 각 스레드에서 작업을 병렬로 실행한다.
strand에 바인딩된 작업들은 서로 간섭하지 않도록 순차적으로 실행된다.
각 스레드에서 strand가 적용되지 않은 작업들은 병렬로 실행될 수 있다.

이를 수식으로 나타내면, 작업들이 strand에 바인딩된 경우 순차적인 실행 순서가 보장되며, 그렇지 않은 경우에는 병렬로 실행된다:

$\mathbf{T_1} \rightarrow \mathbf{T_2} \quad \text{(strand에 의해 직렬화)} \quad \text{and} \quad \mathbf{T_3} \parallel \mathbf{T_4} \quad \text{(병렬로 실행)}$

Strand와 io_context의 성능 고려사항

멀티스레드 io_context와 strand의 조합을 사용할 때는 성능을 고려해야 한다. strand는 작업들의 순차 실행을 보장하기 때문에, 모든 작업이 strand에 바인딩될 경우, 프로그램의 성능이 병목에 걸릴 수 있다. 이는 작업들이 너무 많이 직렬화될 경우, 병렬 처리가 이루어지지 않아 전체 성능이 저하될 수 있기 때문이다.

이를 피하기 위해서는 다음과 같은 전략을 사용할 수 있다:

필요한 자원에 대해서만 strand를 사용: 특정 자원에만 동기화가 필요하다면, 해당 자원에 접근하는 작업들에만 strand를 적용하고, 나머지 작업들은 병렬로 처리하도록 한다.
작업 분할: 대규모 작업은 더 작은 작업으로 나누어, 필요할 때만 strand에 바인딩하도록 한다. 이를 통해 각 작업 간의 병렬 처리가 보다 효율적으로 이루어질 수 있다.
적절한 스레드 수 관리: io_context에 할당된 스레드의 수는 성능에 영향을 미친다. 너무 적은 스레드는 병렬 처리의 이점을 감소시키고, 너무 많은 스레드는 오히려 컨텍스트 스위칭 비용을 증가시킬 수 있다. 따라서 io_context의 스레드 풀 크기를 적절히 조절하는 것이 중요하다.

Strand와 Mutex의 비교

전통적으로, 멀티스레드 환경에서 자원에 대한 동기화를 보장하기 위해 뮤텍스(mutex)와 락(lock)을 사용해왔다. 그러나 이러한 동기화 방법은 프로그래머가 직접 락을 관리해야 하며, 잠재적인 데드락(deadlock)이나 성능 저하와 같은 문제를 초래할 수 있다.

Boost.Asio의 strand는 이러한 전통적인 동기화 기법의 대안으로, 더 간단하게 비동기 작업 간의 자원 경합을 해결한다. strand는 락을 사용할 필요 없이, 작업들이 순차적으로 실행되도록 보장한다. 따라서 데드락의 위험이 없으며, 복잡한 락 관리 코드를 줄일 수 있다.

Mutex와 strand의 차이점

동작 방식:
Mutex는 작업이 자원에 접근할 때 락을 획득하고, 작업이 완료되면 락을 해제하는 방식으로 동작한다.
Strand는 자원에 접근하는 모든 작업을 순차적으로 실행하여, 락 없이도 자원 접근의 일관성을 보장한다.
데드락의 위험:
Mutex는 데드락이 발생할 수 있다. 예를 들어, 두 개 이상의 스레드가 서로 다른 락을 획득하려고 할 때 데드락 상황이 발생할 수 있다.
Strand는 작업들이 순차적으로 실행되므로, 데드락이 발생하지 않는다.
성능:
Mutex는 스레드가 락을 해제할 때까지 다른 스레드들이 대기해야 하는 비용이 발생한다.
Strand는 작업을 순차적으로 처리하므로 락 대기 시간이 없으며, 자원에 대한 접근이 더 효율적이다.

성능 비교 수식

Mutex와 strand의 성능을 수식으로 비교하면, 두 스레드가 동일한 자원에 접근하는 경우를 가정할 수 있다. Mutex를 사용할 때는 다음과 같이 각 스레드가 락을 획득하고 해제하는 과정이 발생한다:

$\text{시간} = t_{\text{lock}} + t_{\text{작업}} + t_{\text{unlock}}$

여기서 $t_{\text{lock}}$ 은 락을 획득하는 데 걸리는 시간, $t_{\text{작업}}$ 은 작업을 수행하는 시간, $t_{\text{unlock}}$ 은 락을 해제하는 시간이다. 만약 스레드가 락을 획득하기까지 대기해야 한다면, 전체 시간이 더 길어진다.

Strand를 사용할 경우, 작업은 순차적으로 실행되므로 락 대기 시간이 없으며, 다음과 같이 계산할 수 있다:

$\text{시간} = t_{\text{작업}}_1 + t_{\text{작업}}_2$

이때, strand의 장점은 락과 같은 대기 시간 없이 자원 접근을 직렬화하여 처리할 수 있다는 점에 있다.

Strand와 동시성 제어의 확장

Boost.Asio의 strand는 단일 자원에 대한 동기화뿐만 아니라, 여러 자원에 대한 동시성 제어에도 확장하여 사용할 수 있다. 이는 복잡한 애플리케이션에서 각 자원에 대해 별도의 strand를 생성하고, 각 자원에 대한 작업들을 개별적으로 직렬화함으로써 동시성 및 효율성을 극대화할 수 있게 한다. 자원마다 다른 strand를 할당하여 자원 간의 상호작용을 제어할 수 있으며, 자원 충돌을 예방할 수 있다.

자원별 strand 사용 예시

예를 들어, 시스템에 두 개의 자원 $\mathbf{R_1}$ 과 $\mathbf{R_2}$ 가 존재한다고 가정할 때, 각 자원에 대한 작업을 별도의 strand로 처리하여 자원 간 간섭을 방지할 수 있다. 이를 코드로 표현하면 다음과 같다:

boost::asio::io_context io_context;
boost::asio::strand<boost::asio::io_context::executor_type> strand1(io_context.get_executor());
boost::asio::strand<boost::asio::io_context::executor_type> strand2(io_context.get_executor());

int resource1 = 0;
int resource2 = 0;

// resource1에 대한 작업은 strand1을 통해 직렬화
io_context.post(strand1.wrap([&resource1](){ resource1 += 1; }));

// resource2에 대한 작업은 strand2을 통해 직렬화
io_context.post(strand2.wrap([&resource2](){ resource2 += 1; }));

io_context.run();

위 코드는 두 개의 자원이 각기 다른 strand에 바인딩되어 자원 간 충돌 없이 동시에 처리된다. 이를 통해 자원들 간의 독립성을 보장하면서도 각각의 작업을 병렬로 수행할 수 있다.

자원 간의 의존성을 가진 상황

만약 두 자원 간에 의존성이 존재할 경우에는 각 자원에 대한 작업을 순차적으로 처리해야 할 필요가 있다. 이때도 strand는 유용하다. 예를 들어, 자원 $\mathbf{R_1}$ 에 대한 작업이 완료된 후에만 자원 $\mathbf{R_2}$ 에 대한 작업이 실행되어야 한다면, 이를 strand를 통해 조정할 수 있다. 수식으로 표현하면, 다음과 같이 작업 순서를 보장할 수 있다:

$\mathbf{T_1}(R_1) \rightarrow \mathbf{T_2}(R_2)$

이때 $\mathbf{T_1}$ 은 자원 $\mathbf{R_1}$ 에 대한 작업, $\mathbf{T_2}$ 는 자원 $\mathbf{R_2}$ 에 대한 작업이다. strand는 이러한 의존 관계를 관리하며, 자원 간의 충돌을 방지한다.

복합 자원 작업 시의 strand 사용

자원이 두 개 이상일 때, 하나의 strand로 모든 자원을 관리하는 대신, 각 자원에 대한 strand를 개별적으로 생성하여 효율성을 극대화할 수 있다. 하지만, 때로는 특정 작업이 여러 자원에 걸쳐 영향을 미치기 때문에, 이러한 작업들을 조정할 필요가 있다.

다음은 두 자원을 동시에 다루는 복합 작업의 예시이다:

boost::asio::strand<boost::asio::io_context::executor_type> strand(io_context.get_executor());

int resource1 = 0;
int resource2 = 0;

// 복합 작업이 두 자원에 동시에 접근하는 경우 strand로 직렬화
io_context.post(strand.wrap([&resource1, &resource2](){ 
    resource1 += 1;
    resource2 += 1;
}));

위 코드에서 strand는 두 자원에 대한 작업이 동시에 발생하는 경우에도, 두 자원이 동시에 접근되지 않도록 보장한다. 이를 통해 두 자원에 대한 일관성을 유지하며 작업을 안전하게 처리할 수 있다.

Strand와 상태 머신

복잡한 비동기 시스템에서는 상태 머신(State Machine)을 자주 사용한다. 상태 머신은 시스템이 특정 상태에서 상태 전환을 통해 다음 작업으로 넘어가는 구조를 취한다. Boost.Asio의 strand는 이러한 상태 머신에서의 상태 전환을 안전하게 처리하기 위해 사용할 수 있다.

상태 머신에서 각 상태 전환이 strand를 통해 직렬화된다면, 여러 상태 전환이 동시에 발생하지 않도록 할 수 있다. 즉, 상태 전환은 하나씩 순차적으로 처리되며, 각 상태가 완료된 후에 다음 상태로 안전하게 넘어갈 수 있다.

다음은 상태 머신과 strand를 함께 사용하는 예시이다:

enum class State { Idle, Processing, Completed };

State current_state = State::Idle;
boost::asio::strand<boost::asio::io_context::executor_type> strand(io_context.get_executor());

io_context.post(strand.wrap([&current_state](){
    if (current_state == State::Idle) {
        std::cout << "Idle 상태에서 Processing으로 전환" << std::endl;
        current_state = State::Processing;
    }
}));

위 코드는 상태 머신의 상태 전환을 strand로 직렬화하여 처리하고 있다. 이로 인해 여러 상태 전환이 동시에 발생하지 않으며, 상태 간의 충돌을 방지할 수 있다.

상태 머신의 수학적 모델

상태 머신의 각 상태를 $\mathbf{S_1}, \mathbf{S_2}, \dots, \mathbf{S_n}$ 으로 나타낼 수 있다. 상태 전환이 순차적으로 이루어져야 하므로, strand를 사용하면 각 상태는 다음과 같은 순서로 직렬화되어 처리된다:

$\mathbf{S_1} \rightarrow \mathbf{S_2} \rightarrow \dots \rightarrow \mathbf{S_n}$

이때, 각 상태 전환은 strand에 의해 보장되며, 동시에 발생하는 상태 전환이 없도록 조정된다.

Strand와 타이머 작업

Boost.Asio에서 자주 사용하는 비동기 작업 중 하나는 타이머(timer) 작업이다. 타이머 작업 역시 strand와 결합하여 안전하게 사용할 수 있다. 예를 들어, 특정 시간이 경과한 후 실행되는 작업이 여러 개 존재할 경우, strand를 통해 이러한 타이머 작업들 간의 충돌을 방지할 수 있다.

다음은 타이머 작업을 strand와 함께 사용하는 예시이다:

boost::asio::steady_timer timer(io_context, boost::asio::chrono::seconds(1));
boost::asio::strand<boost::asio::io_context::executor_type> strand(io_context.get_executor());

timer.async_wait(strand.wrap([](){
    std::cout << "타이머 작업 실행" << std::endl;
}));

위 코드에서 타이머가 만료된 후 실행될 작업은 strand에 바인딩되며, 다른 작업들과 충돌 없이 순차적으로 실행된다. 이를 통해 타이머 작업이 안전하게 실행됨을 보장할 수 있다.

타이머 작업이 여러 개일 때, strand는 각 타이머 작업 간의 순서를 보장하여 타이머가 만료되는 순서대로 작업을 실행하게 한다. 수식으로 나타내면, 각 타이머 작업 $\mathbf{T_1}, \mathbf{T_2}, \dots$ 은 다음과 같은 순서로 실행된다:

$\mathbf{T_1} \rightarrow \mathbf{T_2} \rightarrow \dots$

이를 통해 타이머 작업이 비동기 시스템에서 올바르게 처리될 수 있다.