[C#] 비동기 코드 async / await / Task 작성 및 내부 구현

비동기 코드 작성

 

C# 5의 핵심 기능으로 기존에 사용하던 TPL을 기반으로한 async / await이 등장했고, 이 기능을 이용하면 동기 코드와 매우 유사한 방식으로 비동기 코드를 작성할 수 있다.

 

작업이 완료될 때까지 아래에 있는 코드가 수행되지 않는다는 면에서 블로킹 호출과 유사하지만, 현재 수행 중인 스레드를 블로킹하지 않는다는 점에서 큰 차이가 있다.

 

비동기 함수란, async 한정자를 사용하여 선언한 메서드의 익명 함수를 말하며, await 연산자를 이용하여 '대기' 를 표현할 수 있다.

await의 주요 목적은 시간을 많이 소비하는 작업이 완료될 때까지 수행이 중단되는 것을 막는 것이다.

 

public class Program {
    private static async Task Main(string[] args) {
        Task<string> userDataTask = GetUserData();
        Task<string> eventDataTask = GetEventData();

        string userData = await userDataTask;
        string eventData = await eventDataTask;

        Console.WriteLine($"{userData} : {eventData}");
    }

    private static async Task<string> GetUserData() {
        Console.WriteLine("Start GetUserData");
        await Task.Delay(500);
        Console.WriteLine("End GetUserData");
        return "user_id";
    }
    
    private static async Task<string> GetEventData() {
        Console.WriteLine("Start GetEventData");
        await Task.Delay(500);
        Console.WriteLine("End GetEventData");
        return "event_id";
    }
}

 

결괏값:

Start GetUserData
Start GetEventData
End GetUserData
End GetEventData
user_id : event_id

 

 

await 표현식에 도달하면, await 코드가 취하려는 결괏값이 존재하는지 확인하게 되는데, 아직 값이 준비되지 않았다면 다음 컨티뉴에이션을 스케줄링한다.

컨티뉴에이션이란, 비동기 작업이 완료되었을 때 수행할 콜백을 말한다. (정확히는 메서드의 수행 상태를 저장하는 용도로 사용되고, 현재의 수행 위치를 관리한다.)

ContinueWith() 과 같이 다음 수행 지점을 직접 지정할 수 있는 메서드도 있다.

비동기 메서드의 제어 흐름은 컨티뉴에이션을 이용한다. 어떤 작업을 요청할 때 그 작업이 완료된 이후에 무엇을 할 지를 미리 알려주는 방식이다.

await을 사용하면 컴파일러가 컨티뉴에이션을 생성해 준다.

 

Task 기반의 비동기는 컨티뉴에이션이 직접 전달되는 대신, 이를 나타내는 토큰이 반환된다. 이 토큰은 수행을 요청한 작업을 나타낸다. 

작업 수행 - 비동기 작업 시작, 반환된 토큰 기록 - 가능하다면 다른 작업 수행 - 비동기 작업이 완료되기를 기다림 - 다른 작업을 수행 - 완료

 

async 한정자는 어떠한 코드도 생성하지 않는다. Task 객체를 반환하는 일반 메서드와 전혀 다를 바가 없다.

이런 이유로 기존 메서드에 async를 추가하더라도 소스와 바이너리 차원에서 완전한 호환을 유지할 수 있다.

 

추상 메서드와 인터페이스 내에 메서드를 async로 선언할 수 없지만, 반환 타입을 Task 형태로 선언하기만 한다면 인터페이스 내에서도 완벽하게 호환되는 비동기 메서드를 선언할 수 있다.

 

public interface IMyInterface {
    public Task AsyncMethod();
}

public class MyClass : IMyInterface {
    public async Task AsyncMethod() {
        await Task.Delay(500);
        Console.WriteLine("Hello");
    }
}

public class Program {
    private static async Task Main(string[] args) {
        var myClass = new MyClass();
        await myClass.AsyncMethod();
        Console.WriteLine("World");
    }
}

 

결괏값:

Hello
World

 

 

C# 5까지의 비동기 메서드의 반환 타입은 void, Task, Task<T>가 있다. Task<T>는 Task를 상속받고, 작업이 완료되었을 때 T 타입의 값을 반환한다. Task는 아무 값도 반환하지 않는다.

 

비동기 메서드가 void 타입을 반환할 수 있도록 허용한 이유는 이벤트 핸들러와의 호환성을 유지하기 위함이다.

해당 이벤트를 일으키는 코드는 이벤트 핸들러가 언제 종료되는지 알아야 할 필요가 없으며, 그저 호출하는 것만으로 충분하다.

비동기 메서드를 이벤트 핸들러로 사용할 때만 반환 값을 void로 지정하는 것이 좋다. 그래야만 비동기 작업이 완료될 때까지 대기할 수 있으며, 실패를 감지할 수 있다.

 

비동기 메서드의 매개변수에는 out이나 ref를 사용할 수 없다.

이 한정자들은 모두 호출 측 코드로 다시 데이터를 전달하기 위한 것이기 때문이다. 일부 미동기 메서드는 호출 측으로 반환되지 않는다.

 

Task 이외에도 await 연산자를 사용할 수 있는 대기 가능 패턴이 있다.

INotifyCompletion 인터페이스 구현, 읽기 가능한 IsCompleted 속성 포함, 매개 변수가 없는 GetResult() 메서드를 포함시켜야 한다.

예로 Task.Yield() 메서드는 YieldAwaitable 타입의 객체를 반환하는데, 이 객체는 위의 대기 가능 패턴을 준수하기 때문에 await 표현식 사용이 가능하다.

await Task.Yield();

 

반환 타입이 대기자 타입인 GetAwaiter()를 확장 메서드로 작성할 수도 있다. 이는 이전에 출시된 .NET 버전과의 상호 운용성과 관련있다. (.NET 4.0에서 4.5로 유저들이 편하게 옮겨갈 수 있게 하기 위함)

 

비동기 메서드는 완료된 작업을 await할 때는 반환되지 않고, 동기적으로 수행된다.

await 표현식을 만났을 때, 그 작업이 이미 완료되어있다면 결괏값을 획득하고 다음 작업을 계속 수행한다.

반대로 작업이 이미 완료되지 않은 경우에는 컨티뉴에이션 결합 이후 반환되고, 이후에 컨티뉴에이션을 수행한 뒤 결괏값을 획득할 수 있다.

 

Task는 실패를 여러가지 방법으로 나타낸다. Task 객체의 Status가 Faulted로 바뀌기도 하고, Exception 속성은 AggregateException 타입의 객체를 반환하기도 한다. 이는 요청한 작업이 유발한 모든 예외를 저장할 수 있다.

Task는 CancellationTokenSource와 CancellationToken을 이용하여 작업의 수행 취소를 지원하기도 한다. 작업이 취소되면 OperationCanceledException 예외를 포함하는 AggregateException 을 던진다. Status 속성은 Canceled가 된다.

 

Task 작업을 대기하는 도중에도 해당 작업이 실패하거나 취소될 수 있는데, 이 경우에는 AggregateException이 아니라 단일 예외가 발생하며, AggregateException의 첫 번째 예외에 해당된다. 이는 예외 처리의 편의성을 도모하기 위함이다.

 

public class Program {
    private static async Task Main(string[] args) {
        var cts = new CancellationTokenSource();

        Task printTask = PrintAsync(cts.Token);
        cts.Cancel();

        await printTask;
        
        cts.Dispose();
    }

    private static async Task PrintAsync(CancellationToken cancellationToken) {
        try {
            Console.WriteLine("Start PrintAsync");
            await Task.Delay(100000, cancellationToken);
        } catch (OperationCanceledException) {
            Console.WriteLine("PrintAsync was cancelled");
            return;
        }

        Console.WriteLine("Hi, there");
    }
}

 

결괏값:

Start PrintAsync
PrintAsync was cancelled

 

비동기 메서드가 예외를 던지더라도, 호출하는 측에서 await 표현식을 만나기 전까지는 호출 측으로 예외가 전파되지 않는다.

 

ValueTask는 Task의 값 타입이다. 힙 할당은 가비지 수집으로 이어지기 때문에 값 타입 사용으로 이를 피할 수 있다.

await 표현식은 즉각적으로 반환되지만, 지금 대기 중인 작업이 완료되면 코드의 나머지 부분을 실행하기 위해 컨티뉴에이션을 스케줄링하게 된다. 이 과정에서 이미 완료된 작업이 아닌 이상 새로운 Task 객체를 생성하는 것을 피할 수 없다.

이미 완료된 작업에 대해 대기 작업을 많이 수행한다면 ValueTask가 유용하다.

 

 

비동기 코드 내부 구현

private async Task PrintAndAwait(int delayMilliSeconds){
    Console.WriteLine("Before");
    
    await Task.Delay(delayMilliSeconds);
    
    Console.WriteLine("Between");
    
    await Task.Delay(delayMilliSeconds);
    
    Console.WriteLine("After");
}

 

위의 예제를 기준으로 컴파일러가 비동기 코드를 어떻게 변환하는지 알아보자.

 

비동기의 내부 구현체 즉, 비동기와 연관된 부분과 컴파일러가 실제로 생성한 코드는 모두 상태 머신 형태를 취하고 있다.

 

[CompilerGenerated]
private sealed class MyStateMachine : IAsyncStateMachine {
    public int state;
    public AsyncTaskMethodBuilder asyncTaskMethodBuilder;
    public int delayMilliSeconds;
    public Example thisInstance;
    private TaskAwaiter taskAwaiter;
        
    ...
}

private Task PrintAndAwait() {
    MyStateMachine stateMachine = new MyStateMachine();
    stateMachine.asyncTaskMethodBuilder = AsyncTaskMethodBuilder.Create();
    stateMachine.thisInstance = this;
    stateMachine.state = -1;
    stateMachine.asyncTaskMethodBuilder.Start(ref stateMachine);
    return stateMachine.asyncTaskMethodBuilder.Task;
}

 

컴파일러는 비동기 메서드를 표현하기 위해서 private으로 선언된 중첩 구조체(혹은 클래스)를 생성하고, 사용자가 선언한 메서드와 동일한 원형의 메서드를 둔다. 이를 스텁 메서드라고 부른다.

스텁 메서드는 상태 머신을 생성하여 매개변수나 상태와 같이 AsyncTaskMethodBuilder 라는 핵심 빌더를 생성해 시작시키고 해당 Task를 반환한다. 머신과 빌더는 모두 값 타입이다.

 

// AsyncTaskMethodBuilderCore.cs
public static void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine {
    Thread currentThread = Thread.CurrentThread;

    ExecutionContext? previousExecutionCtx = currentThread._executionContext;
    SynchronizationContext? previousSyncCtx = currentThread._synchronizationContext;

    try {
        stateMachine.MoveNext();
    } finally {
        if (previousSyncCtx != currentThread._synchronizationContext) {
            currentThread._synchronizationContext = previousSyncCtx;
        }

        ExecutionContext? currentExecutionCtx = currentThread._executionContext;
        if (previousExecutionCtx != currentExecutionCtx) {
            ExecutionContext.RestoreChangedContextToThread(currentThread, previousExecutionCtx, currentExecutionCtx);
        }
    }
}

 

빌더의 Start() 를 호출하고 생성한 머신을 파라미터로 전달한다. 대기해야 할 때까지 상태 머신을 수행한 뒤 빌더의 Task 객체를 반환한다. 이 메서드는 내부적으로 약간의 사전 작업을 수행한 후, 상태 머신의 MoveNext()를 호출하여 상태머신이 비동기 메서드 내의 한 단계를 수행하도록 한다.

 

상태 머신을 수행한다고 해서 새로운 스레드를 생성하는 것은 아니며, MoveNext() 메서드를 호출하는 작업만을 수행한다.

이같은 동작은 작업이 완료되거나 다른 비동기 작업을 대기하기 위해 스레드를 일시 중단할 때까지 계속된다.

 

상태 머신은 비동기 메서드 내에서 현재 수행 위치를 저장한다. 논리적으로 실행 단계는 시작 전, 실행 중, 일시 중단, 완료 이 네 가지 상태로 구분되며, 일시 중단이 발생할 때마다 지금 수행한 위치 다음부터 수행을 이어하기 위해 별도의 상태를 저장한다. 

 

상태 머신은 IAsyncStateMachine 인터페이스를 구현하고 있으며, MoveNext()와 SetStateMachine() 두 개의 메서드만 가지고 있다.

 

private void MoveNext() {
    int num = state;
    try {
        TaskAwaiter awaiter;
        TaskAwaiter awaiter2;

        if (num != 0) {
            if (num == 1) {
                awaiter = taskAwaiter;
                taskAwaiter = default(TaskAwaiter);
                num = (state = -1);
                goto IL_00e7;
            }
            Console.WriteLine("Before");
            awaiter2 = Task.Delay(100).GetAwaiter();
            if (!awaiter2.IsCompleted) {
                num = (state = 0);
                taskAwaiter = awaiter2;
                MyStateMachine stateMachine = this;
                asyncTaskMethodBuilder.AwaitUnsafeOnCompleted(ref awaiter2, ref stateMachine);
                return;
            }
        } else {
            awaiter2 = taskAwaiter;
            taskAwaiter = default(TaskAwaiter);
            num = (state = -1);
        }

        awaiter2.GetResult();
        Console.WriteLine("Between");
        awaiter = Task.Delay(100).GetAwaiter();
        if (!awaiter.IsCompleted) {
            num = (state = 1);
            taskAwaiter = awaiter;
            MyStateMachine stateMachine = this;
            asyncTaskMethodBuilder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
            return;
        }

        goto IL_00e7;
        IL_00e7:
        awaiter.GetResult();
        Console.WriteLine("After");
    } catch (Exception exception) {
        state = -2;
        asyncTaskMethodBuilder.SetException(exception);
        return;
    }
    state = -2;
    asyncTaskMethodBuilder.SetResult();
}

 

MoveNext()는 상태 머신이 시작될 때, 그리고 일시 중단되었다가 수행을 재개할 때 호출된다.

MoveNext()가 호출될 때마다 상태 머신은 그다음 단계를 수행한다. 대기 표현식에 도달하면, 대기 중인 값이 완결된 경우 수행을 지속하고, 그렇지 않은 경우 수행을 일시 중단한다.

 

void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine) {
    this.SetStateMachine(stateMachine);
}

 

SetStateMachine()은 필드로 가지고 있는 빌더의 메서드인 SetStateMachine()을 호출하고 인자로 받은 상태 머신을 넘겨 준다.

builder.Start()에 의해 상태 머신이 첫 번째 단계를 수행할 때는 상태 머신이 스텁 메서드의 지역 변수로서 스택에 존재한다.

상태 머신이 일시 중단되면, 자기 자신을 박싱하여 힙에 생성하고 다음번 수행이 재개될 때까지 정보를 보존한다.

그 이후 박싱된 상태머신의 SetStateMachine()이 호출된다. 값 타입이기 때문에 박싱되지 않은 상태로 호출해봐야 박싱된 값에는 영향을 미칠 수 없기 때문이다.

 

결과적으로 필요하지 않은 경우에는 상태 머신이 박싱되지 않고, 반드시 필요한 경우에만 1회 박싱이 이루어진다. 이 이후에는 모든 작업이 박싱된 개체에서 수행된다. (일시 중단될 필요가 없는, 이미 완료된 작업에 의해서는 다음 작업이 필요 없이 동기적으로 진행되기 때문에 이 경우에는 박싱되지 않는다.)

 

또한 상태, 빌더, 대기자, 파라미터들을 필드로 가지고 있으며, 한 단계를 수행한 후 그 다음 단계를 수행하기 위해서 상태 머신이 저장해 두어야 하는 정보를 담고 있다. 즉, 상태 머신이 재개되었을 때 다시 가져와야 하는 값에 대해서만 필드를 구성한다.

상태 머신이 네 가지 상태를 가질 수 있지만 이들을 별도로 구분하여 처리하지 않는다. 실행 중이나 완료 상태를 유지한 상태로 MoveNext()가 호출될 가능성이 없기 때문이다. 일반적인 경우라면 MoveNext()는 상태 머신을 최초로 시작하거나, 실행을 재개할 때만 호출된다.

 

 

비동기 메서드가 이미 완료된 작업일 때 흐름 (예제의 delayMilliSeconds가 0일 때)

MoveNext 호출 - 상태 머신의 처음 state는 [시작 전]
 - “Before” 출력 - 첫번째 Task.Delay().GetAwaiter()하여 이미 완료된 값이면 GetResult()
 - “Between” 출력 - 두번째 Task.Delay().GetAwaiter()하여 이미 완료된 값이면 GetResult()
 - “After” 출력 - state를 [완료]로 변경하고 builder.SetResult() 를 통해 메서드 완료를 전파

 

builder.AwaitUnsafeOnComplete()를 호출하지 않고, 실행 중간에 반환 및 상태 변화가 없다.

 

 

비동기 메서드가 완료되지 않은 작업일 때 흐름 (예제의 delayMilliSeconds가 양수일 때)

MoveNext 호출 - 상태 머신의 처음 state는 [시작 전]
 - “Before” 출력 - 첫번째 Task.Delay().GetAwaiter()하여 아직 완료되지 않았으면 필드에 awaiter 저장하고 state를 [일시 중단]으로 변경 
 - builder.AwaitUnsafeOnComplete() 이후 반환 (내부에서 컨티뉴에이션 스케줄링)
 - 다시 MoveNext 호출 → 첫 번째 컨티뉴에이션으로 넘어가 필드를 초기화하고 state를 [실행 중]으로 변경 - GetResult()
 - “Between” 출력 - 두번째 Task.Delay().GetAwaiter()하여 아직 완료되지 않았으면 필드에 awaiter 저장하고 state를 [일시 중단]으로 변경 
 - builder.AwaitUnsafeOnComplete() 이후 반환 (내부에서 컨티뉴에이션 스케줄링)
 - 다시 MoveNext 호출 - 두 번째 컨티뉴에이션으로 넘어가 필드를 초기화하고 state를 [실행 중]으로 변경
 - GetResult() - “After” 출력 - state를 [완료]로 변경하고 builder.SetResult() 를 통해 메서드 완료를 전파

 

 

만약, 실행 도중에 예외 발생 시 위의 코드를 감싸는 catch 문에서 state를 [완료]로 변경하고 builder.SetException()을 통해 모든 예외를 전파하고 반환시킨다.

 

 

Jon Skeet,『C#을 다루는 기술』 의 내용을 참고하여 개인적인 공부 목적으로 작성되었습니다.
검색을 허용하지 않고, 수익을 창출하지 않습니다.