[C#] 스레딩

C#에서 스레딩의 사용법은 간단하다.
Thread 클래스에 함수를 인자로 줘서 생성하고,
Start()메서드를 호출하면 된다.
여기에서 함수는 객체의 메서드나 정적 메서드, 람다식이 다 들어갈 수 있다.
대신 함수의 형식은 void(void)여야만 한다. 리턴이나 파라미터가 있으면 안된다.

아래는 실행 예시다.

using System;
using System.Threading;
using System.Collections.Generic;

namespace ThreadingTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("main thread 시작");

            var threads = new List<Thread>();
            threads.Add(new Thread(() => Console.WriteLine("첫번째 thread")));
            threads.Add(new Thread(() => Console.WriteLine("두번째 thread")));
            threads.Add(new Thread(() => Console.WriteLine("세번째 thread")));
            threads.Add(new Thread(() => Console.WriteLine("네번째 thread")));

            //전부 돌림
            foreach (var thread in threads)
                thread.Start();

            Console.WriteLine("main thread 종료");
        }
    }
}

잘 돌아간다.
순서가 제멋대로인건 어쩔수없는 스레딩의 숙명이다.

스레드가 다 끝날때까지 main을 대기시키려면 join을 쓰면 된다.

그리고 데이터 레이스라는 것이 있다.
여러 스레드에서 하나의 변수를 공유할 때 발생하는 문제인데, 예제를 통해 한번 봐보자
하나의 변수를 여러 스레드에서 동시에 증가시키는 코드다.

using System;
using System.Threading;
using System.Collections.Generic;

namespace ThreadingTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("main thread 시작");

            var threads = new List<Thread>();
            int counter = 0;

            //10000씩 증가시킴
            ThreadStart inc = () => {
                for (int i = 0; i < 10000; i++)
                    counter++;
            };

            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));

            //전부 돌림
            foreach (var thread in threads)
                thread.Start();

            //이놈들 끝날때까지 main 블럭
            foreach (var thread in threads)
                thread.Join();

            Console.WriteLine($"{counter}");

            Console.WriteLine("main thread 종료");
        }
    }
}

분명 40000이 나와야하는데 그거보다 덜나왔다.
값을 올리는 와중에 스레드끼리 충돌을 해서 미스가 난 것인데, 이걸 해결하려면 Mutex로 임계구역을 설정해주거나 Atomic 등으로 동기화를 해줘야 한다.

아래는 대략적인 mutex의 사용법이다.

using System;
using System.Threading;
using System.Collections.Generic;

namespace ThreadingTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("main thread 시작");

            var threads = new List<Thread>();
            int counter = 0;
            var locker = new Mutex();

            //10000씩 증가시킴
            ThreadStart inc = () => {
                locker.WaitOne(); //획득 후 잠금
                for (int i = 0; i < 10000; i++)
                    counter++;
                locker.ReleaseMutex(); //잠금 해제
            };

            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));

            //전부 돌림
            foreach (var thread in threads)
                thread.Start();

            //이놈들 끝날때까지 main 블럭
            foreach (var thread in threads)
                thread.Join();

            Console.WriteLine($"{counter}");

            Console.WriteLine("main thread 종료");
        }
    }
}

잘 된다.

그리고 Monitor란 놈도 있다.
하나의 프로세스를 사용할 때만 적합하다. 하지만 Mutex보다 수십배는 빠르다고 한다.

using System;
using System.Threading;
using System.Collections.Generic;

namespace ThreadingTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("main thread 시작");

            var threads = new List<Thread>();
            int counter = 0;
            var locker = new Object();

            //10000씩 증가시킴
            ThreadStart inc = () => {
                Monitor.Enter(locker); //잠금
                for (int i = 0; i < 10000; i++)
                    counter++;
                Monitor.Exit(locker); //잠금 해제

             };

            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));

            //전부 돌림
            foreach (var thread in threads)
                thread.Start();

            //이놈들 끝날때까지 main 블럭
            foreach (var thread in threads)
                thread.Join();

            Console.WriteLine($"카운터는 {counter}");

            Console.WriteLine("main thread 종료");
        }
    }
}

잘 된다.

그리고 C#에서는 이걸 문법으로도 제공한다.
따로 공유해서 잠금 인식용으로 쓸 객체를 만들고 lock 블럭으로 잠금을 거는것이다.

using System;
using System.Threading;
using System.Collections.Generic;

namespace ThreadingTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("main thread 시작");

            var threads = new List<Thread>();
            int counter = 0;
            var locker = new Object(); //잠금용 객체

            //10000씩 증가시킴
            ThreadStart inc = () => {
                lock (locker) //들어가면 잠가버림
                {
                    for (int i = 0; i < 10000; i++)
                        counter++;
                }
             };

            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));

            //전부 돌림
            foreach (var thread in threads)
                thread.Start();

            //이놈들 끝날때까지 main 블럭
            foreach (var thread in threads)
                thread.Join();

            Console.WriteLine($"카운터는 {counter}");

            Console.WriteLine("main thread 종료");
        }
    }
}

그런데 이런 임계구역의 설정은 성능을 엄청나게 잡아먹기 때문에, 최소한으로 사용하는 것이 좋다.

그리고 Atomic, 그러니까 원자적 연산을 활용할 수도 있다.

using System;
using System.Threading;
using System.Collections.Generic;

namespace ThreadingTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("main thread 시작");

            var threads = new List<Thread>();
            int counter = 0;

            //10000씩 증가시킴
            ThreadStart inc = () => {
                for (int i = 0; i < 10000; i++)
                    Interlocked.Increment(ref counter); //atomic 연산
             };

            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));
            threads.Add(new Thread(inc));

            //전부 돌림
            foreach (var thread in threads)
                thread.Start();

            //이놈들 끝날때까지 main 블럭
            foreach (var thread in threads)
                thread.Join();

            Console.WriteLine($"카운터는 {counter}");

            Console.WriteLine("main thread 종료");
        }
    }
}

이것도 잘 된다.
대체로 Mutex를 통한 블럭보다는 원자적 연산을 활용하는 것이 성능은 더 좋다고들 한다.