[C#] 동기/비동기 (feat. Coroutine, Task, async/await)

*동기: 일을 주고 그 일이 끝날때까지 아무것도 안하고 기다리는 것. ex) 매표소 줄

*비동기: 일을 준 후 기다리지 않고 내 일을 하는 것. ex) 커피숍 진동벨

---

#동기식 프로그래밍의 예시

using System;

public class TestClass {

    static void Main(string[] args) {
        PrintNumber();
        PrintStart();

        Console.ReadKey();
    }

    private static void PrintNumber() {
        for(int i = 0; i < 10; i++) {
            Console.WriteLine(i);
        }
    }

    private static void PrintStart() {
        for (int i = 0; i < 10; i++) {
            Console.WriteLine("*");
        }
    }
}

0 1 2 3 4 ... * * * * ...

PrintNumber(), PrintStart() 함수가 순차적으로 실행된다.

 

#비동기식 프로그래밍(Thread)의 예시

using System;
using System.Threading;

public class TestClass {

    static void Main(string[] args) {

        var thread1 = new Thread(PrintNumber);
        thread1.Start();

        var thread2 = new Thread(PrintStart);
        thread2.Start();

        Console.ReadKey();
    }

    private static void PrintNumber() {
        for(int i = 0; i < 10; i++) {
            Console.WriteLine(i);
        }
    }

    private static void PrintStart() {
        for (int i = 0; i < 10; i++) {
            Console.WriteLine("*");
        }
    }
}

0 * 1 * 2 * ...

PrintNumber(), PrintStart() 함수가 동시에 실행된다.

 

*Thread의 문제점

Thread 는 return 값이 없는 class 이다. (기능이 매우 한정적)

Thread 의 종료시점을 알 수 없다.

Thread 는 취소/예외처리를 할 수 없다.

Thread는 1MB 로 상당히 무거운 객체이다.

생성할 때마다 참조되어 있는 모든 DLL 을 돌면서 공간할당을 요청한다. 

 

Thread의 문제점을 해결하기 위해 나온게 Task !

Thread pool로 부터 Thread를 가져와서 비동기 작업을 수행한다.

Task Chain 개념이 도입되어 여러 Thread 를 순차적으로 동작하게 한다.

 

Task 반환값 앞에 async 키워드를 붙인다.

대기가 필요하면(동기처럼) await 키워드를 사용하자. 메소드는 잠시 중단되고 프로그램은 계속 진행한다.

Task 의 반환값은 void, Task, Task<T> 셋 중에 하나로 사용할 수 있다.

 

# Task 예시 1) Action

public class TestClass : MonoBehaviour {

    private void Start() {
        Task task1 = new Task(PrintNumber);
        task1.Start();

        Task task2 = new Task(PrintStart);
        task2.Start();
    }

    private void PrintNumber() {
        for (int i = 0; i < 10; i++) {
            Debug.Log(i);
        }
    }

    private void PrintStart() {
        for (int i = 0; i < 10; i++) {
            Debug.Log("*");
        }
    }
}

Thread 를 Task 로만 바꿨고 비동기로 잘 실행되는 모습이다.

public class TestClass : MonoBehaviour {

    private void Start() {
        Task.Run(PrintNumber);
        Task.Run(PrintStart);
    }

    private void PrintNumber() {
        for (int i = 0; i < 10; i++) {
            Debug.Log(i);
        }
    }

    private void PrintStart() {
        for (int i = 0; i < 10; i++) {
            Debug.Log("*");
        }
    }
}

인자가 없는 메소드라면 Task.Run(함수명) 로 간단히 부를 수도 있다.

public class TestClass : MonoBehaviour {

    private void Start() {
        Task.Run(() => PrintNumber());
        Task.Run(() => PrintStart());
    }

    private void PrintNumber() {
        for (int i = 0; i < 5; i++) {
            Debug.Log(i);
        }
    }

    private void PrintStart() {
        for (int i = 0; i < 5; i++) {
            Debug.Log("*");
        }
    }
}

람다식 표현은 위와 같다.

 

# Task 예시 2)  Task<T>

public class TestClass : MonoBehaviour {

    private void Start() {

        Task<int> task = new Task<int>(GetResult);
        task.Start();
        Debug.Log(task.Result); // 결과값 대기

        Task.Run(() => PrintNumber());
        Task.Run(() => PrintStar());
    }

    private void PrintNumber() {
        for (int i = 0; i < 5; i++) {
            Debug.Log(i);
        }
    }

    private void PrintStar() {
        for (int i = 0; i < 5; i++) {
            Debug.Log("*");
        }
    }

    private int GetResult() {
        for (int i = 0; i < 5; i++) {
            Debug.Log("/");
        }
        return 1;
    }
}

Task 로 넣은 함수의 결과값을 받을 수 있는데 task.Result 구문은 해당 위치에서 결과값을 대기하게 된다.

해당 함수 안에 이후 행동을 넣으면 비동기식으로 잘 활용할 수 있을듯.

 

 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Threading.Tasks;


public class Example : MonoBehaviour
{
    int number = 0;

    private void Start() {
        Task.Run(() => Testing());
    }

    async Task Testing() {
        await Task.Run(() => {
            while(number < 50) {
                number++;
            }
        });
        await Task.Delay(5000);
    }
}

Task 는 값을 반환하지 않는 비동기 작업,

Task<TResult>는 값을 반환할 수 있는 비동기 작업이다.

 

비동기로 처리되어야 하는 부분에 await 연산자를 적용해준다.

 

 

P.S) Coroutine 은 비동기일까?

프레임의 흐름을 넘겨주며 완벽한 비동기 방식이 아닌 프레임을 관리하는 방식이다.

null, WaitForSecond, WaitForFixedUpdate, WaitForEndOfFrame, WaitUntil 등 시간에 따라 대기하는 방식이다.

async/await 와의 차이점은 return 값을 받을 수 있냐 없냐의 차이. 상황에 따라 사용하면 된다.

using System;
using System.Collections;

class Program {

    public IEnumerator Coroutine() {
        int i = 0;
        Console.WriteLine($"Coroutine {++i}");
        yield return null;

        Console.WriteLine($"Coroutine {++i}");
        yield return null;

        Console.WriteLine($"Coroutine {++i}");
        yield return null;
    }
    
    static void Main(string[] args) {
        Program program = new Program();
        IEnumerator coroutine = program.Coroutine();

        Console.WriteLine("Main 1");
        coroutine.MoveNext();
        Console.WriteLine("Main 2");
        coroutine.MoveNext();
        Console.WriteLine("Main 3");
        coroutine.MoveNext();
    }
}

// OUTPUT :
// Main 1
// Coroutine 1
// Main 2
// Coroutine 2
// Main 3
// Coroutine 3

출처: https://kukuta.tistory.com/371