[This is C#] Chapter 19. 스레드와 태스크

[Flags]
enum MyEnum
{
    Apple = 1 << 0,
    Orange = 1 << 1,
    Kiwi = 1 << 2,
    Mango = 1 << 3,
};

Console.WriteLine((MyEnum) 1);       // Apple
Console.WriteLine((MyEnum) (1 | 4)); // Apple, Kiwi 
// Flags 애트리뷰트를 갖고 있는 열거형은 요소의 집합으로 표현될 수 있다.

Thread th = new Thread(...);

if ((th.ThreadState & ThreadState.Aborted) == ThreadState.Aborted)
    Console.WriteLine("스레드가 정지했습니다.");
else if ((th.ThreadState & ThreadState.Stopped) == ThreadState.Stopped)
    Console.WriteLine("스레드가 취소되었습니다.");

class Counter
{
    const int LOOP_COUNT = 100;

    private readonly object thisLock;

    private int count;
    public int Count { get => count; }

    public Counter()
    {
        thisLock = new object();
        count = 0;
    }

    public void Increase()
    {
        int loopCount = LOOP_COUNT;
        while (loopCount-- > 0)
        {
            lock (thisLock) // 여기는 크리티컬 섹션이다
            {
                count++;
                Console.WriteLine($"Increase: {count}");
            }
            Thread.Sleep(1);
        }
    }

    public void Decrease()
    {
        int loopCount = LOOP_COUNT;
        while (loopCount-- > 0)
        {
            lock (thisLock) // 여기는 크리티컬 섹션이다
            {
                count--;
                Console.WriteLine($"Decrease: {count}");
            }
            Thread.Sleep(1);
        }
    }
}

class MainApp
{
    static void Main(string[] args)
    {
        Counter counter = new Counter();

        // 두 개의 스레드 
        Thread inc = new Thread(new ThreadStart(counter.Increase));
        Thread dec = new Thread(new ThreadStart(counter.Decrease));

        // 스레드 시작
        inc.Start();
        dec.Start();

        // 스레드가 끝날 때까지 기다린다
        inc.Join();
        dec.Join();

        Console.WriteLine($"Count: {counter.Count}"); // 0
    }
}

public void Increase()
{
    int loopCount = LOOP_COUNT;
    while (loopCount-- > 0)
    {
        Monitor.Enter(thisLock);
        try
        {
            count++;
        }
        finally
        {
            Monitor.Exit(thisLock);
        }
        Thread.Sleep(1);
    }
}

public void Increase()
{
    int loopCount = LOOP_COUNT;
    while (loopCount-- > 0)
    {
        lock (thisLock)
        {
            // count가 0보다 크거나 
            // 다른 스레드에 의해 lockedCount가 true가 되면
            // Wait()으로 블록된다. 
            while (count > 0 || lockedCount == true)
                Monitor.Wait(thisLock);

            lockedCount = true;  // 다른 스레드가 사용하지 못하도록한다. 
            count++;

            lockedCount = false;  
            Monitor.Pulse(thisLock); // 다른 스레드를 깨운다.
        }
        Thread.Sleep(1);
    }
}

// 실행할 작업물
Action action = () =>
{
    Thread.Sleep(1000); // 이 코드에 상관없이 "동기"가 출력된다. 
    Console.WriteLine("비동기");
};

// Task로 할당
Task task = new Task(action);
// 비동기로 실행한다. 
task.Start(); 

Console.WriteLine("동기");

// 비동기 코드가 완료될 때까지 대기한다. 
task.Wait(); 

// 위와 같은 코드인데

// Task의 생성과 시작을 한번에 한다.
var task = Task.Run(() => 
{
    Thread.Sleep(1000);
    Console.WriteLine("비동기");
});

Console.WriteLine("동기");

task.Wait();

var task = Task<List<int>>.Run(() => 
{
    Thread.Sleep(1000);

    List<int> list = new List<int>();
    list.Add(3);
    list.Add(4);
    list.Add(5);

    return list;
});

task.Wait();

List<int> total = new List<int>();
total.Add(0);
total.Add(1);
total.Add(2);

total.AddRange(task.Result.ToArray()); // 0, 1, 2, 3, 4, 5

List<int> total = new List<int>();

// 0부터 100사이의 정수를 메소드의 인수로 넘긴다. 
// 병렬로 처리된다. 
Parallel.For(0, 100, (int i) =>
{
    if (i % 2 == 0)
        lock (total)
            total.Add(i);
});

for (int i = 0; i < total.Count; i++)
    Console.Write($"{total[i]} ");

// void
public async void AsyncFunc()
{ }

// Task
public async Task AsyncFunc()
{ 
        await Task.Delay(1000);
}

// Task<TResult>
public async Task<int> AsyncFunc()
{ 
        await Task.Delay(1000);

        return 1;
}

public static void Main(string[] args)
{
    TaskTest();
    System.Console.WriteLine("Main Thread is NOT Blocked");
    Console.ReadLine();
}
private static async void TaskTest()
{
    await Task.Delay(5000); // 5초를 기다린다. 
    System.Console.WriteLine("TaskTest Done");
}

// async 한정자가 있으므로 await를 가질 수 있다. 
public static async Task Main(string[] args)
{
    Task t = TaskTest1();
    
    System.Console.WriteLine("Do Something Before TaskTest");

    await t; // 여기서 t가 끝날 때까지 기다린다. 

    System.Console.WriteLine("Do Something after TaskTest");

    Console.ReadLine();
}

private static async Task TaskTest1()
{
    await Task.Delay(5000); // 5초를 기다린다. 
    System.Console.WriteLine("TaskTest Done");
}

public static async Task Main(string[] args)
{
    Task<int> t = TaskTest();
            
    for(int i = 0; i < 10; i++)
    {
        System.Console.WriteLine("Do Something Before TaskTest");
    }
 
    int UID = await t; // await을 통해서 반환값을 추출할 수 있다. 
 
    Console.WriteLine($"UserID : {UID}");
 
    Console.ReadLine();
}

private static async Task<int> TaskTest()
{
    int UID = await ...; // DB or server에서 UID 얻어오는 비동기 메서드 호출
    System.Console.WriteLine("TaskTest Done");
 
    return UID;
}

async static private void AsyncMethod(int count)
{
    Console.WriteLine("B");

    // 호출자에게 제어를 돌려주고 아래 코드는 비동기적으로 처리된다. 
    // 아래 Task가 끝나야지 다음 문장이 실행 된다. 
    await Task.Run(async () =>
    {
        for (int i = 0; i < count; i++)
        {
            Console.WriteLine($"{i} / {count} ...");
            await Task.Delay(100); // Thread.Sleep()의 비동기 버전이다. 
        }
    });

    Console.WriteLine("D");
}

static void Caller()
{
    Console.WriteLine("A");

    AsyncMethod(3);

    Console.WriteLine("C");
}

static void Main(string[] args)
{
    Caller();

    Console.ReadLine(); // (프로그램 종료 방지)
}