THREAD Archives - icodebroker

[PYTHON/LANGCHAIN] DirectoryLoader 클래스 : 생성자에서 use_multithreading 인자를 사용해 멀티스레딩 설정하기

■ DirectoryLoader 클래스의 생성자에서 use_multithreading 인자를 사용해 멀티스레딩을 설정하는 방법을 보여준다. ▶ main.py


from langchain_community.document_loaders import DirectoryLoader

directoryLoader = DirectoryLoader(".", glob = "*.md", use_multithreading = True)

documentList = directoryLoader.load()

for document in documentList:
    print(document)
    print()

"""
page_content='첫번째\n\n두번째\n\n세번째\n\n항목1\n\n항목 2\n항목 3\n항목 4' metadata={'source': 'list.md'}

page_content='제목 1단계\n\n제목 2단계\n\n제목 3단계\n\n제목 4단계\n\n제목 5단계\n\n제목 6단계' metadata={'source': 'header.md'}
"""

from langchain_community.document_loaders import DirectoryLoader

directoryLoader = DirectoryLoader(".", glob = "*.md", use_multithreading = True)

documentList = directoryLoader.load()

for document in documentList:

print(document)

print()

"""

page_content='첫번째\n\n두번째\n\n세번째\n\n항목1\n\n항목 2\n항목 3\n항목 4' metadata={'source': 'list.md'}

page_content='제목 1단계\n\n제목 2단계\n\n제목 3단계\n\n제목 4단계\n\n제목 5단계\n\n제목 6단계' metadata={'source': 'header.md'}

"""

▶ requirements.txt


aiohttp==3.9.5
aiosignal==1.3.1
annotated-types==0.7.0
anyio==4.4.0
async-timeout==4.0.3
attrs==23.2.0
backoff==2.2.1
beautifulsoup4==4.12.3
certifi==2024.6.2
chardet==5.2.0
charset-normalizer==3.3.2
click==8.1.7
dataclasses-json==0.6.7
deepdiff==7.0.1
emoji==2.12.1
exceptiongroup==1.2.1
filetype==1.2.0
frozenlist==1.4.1
greenlet==3.0.3
h11==0.14.0
httpcore==1.0.5
httpx==0.27.0
idna==3.7
joblib==1.4.2
jsonpatch==1.33
jsonpath-python==1.0.6
jsonpointer==3.0.0
langchain==0.2.6
langchain-community==0.2.6
langchain-core==0.2.10
langchain-text-splitters==0.2.2
langdetect==1.0.9
langsmith==0.1.82
lxml==5.2.2
Markdown==3.6
marshmallow==3.21.3
multidict==6.0.5
mypy-extensions==1.0.0
nest-asyncio==1.6.0
nltk==3.8.1
numpy==1.26.4
ordered-set==4.1.0
orjson==3.10.5
packaging==24.1
pydantic==2.7.4
pydantic_core==2.18.4
pypdf==4.2.0
python-dateutil==2.9.0.post0
python-iso639==2024.4.27
python-magic==0.4.27
PyYAML==6.0.1
rapidfuzz==3.9.3
regex==2024.5.15
requests==2.32.3
requests-toolbelt==1.0.0
six==1.16.0
sniffio==1.3.1
soupsieve==2.5
SQLAlchemy==2.0.31
tabulate==0.9.0
tenacity==8.4.2
tqdm==4.66.4
typing-inspect==0.9.0
typing_extensions==4.12.2
unstructured==0.14.8
unstructured-client==0.23.7
urllib3==2.2.2
wrapt==1.16.0
yarl==1.9.4

aiohttp==3.9.5

aiosignal==1.3.1

annotated-types==0.7.0

anyio==4.4.0

async-timeout==4.0.3

attrs==23.2.0

backoff==2.2.1

beautifulsoup4==4.12.3

certifi==2024.6.2

chardet==5.2.0

charset-normalizer==3.3.2

click==8.1.7

dataclasses-json==0.6.7

deepdiff==7.0.1

emoji==2.12.1

exceptiongroup==1.2.1

filetype==1.2.0

frozenlist==1.4.1

greenlet==3.0.3

h11==0.14.0

httpcore==1.0.5

httpx==0.27.0

idna==3.7

joblib==1.4.2

jsonpatch==1.33

jsonpath-python==1.0.6

jsonpointer==3.0.0

langchain==0.2.6

langchain-community==0.2.6

langchain-core==0.2.10

langchain-text-splitters==0.2.2

langdetect==1.0.9

langsmith==0.1.82

lxml==5.2.2

Markdown==3.6

marshmallow==3.21.3

multidict==6.0.5

mypy-extensions==1.0.0

nest-asyncio==1.6.0

nltk==3.8.1

numpy==1.26.4

ordered-set==4.1.0

orjson==3.10.5

packaging==24.1

pydantic==2.7.4

pydantic_core==2.18.4

pypdf==4.2.0

python-dateutil==2.9.0.post0

python-iso639==2024.4.27

python-magic==0.4.27

PyYAML==6.0.1

rapidfuzz==3.9.3

regex==2024.5.15

requests==2.32.3

requests-toolbelt==1.0.0

six==1.16.0

sniffio==1.3.1

soupsieve==2.5

SQLAlchemy==2.0.31

tabulate==0.9.0

tenacity==8.4.2

tqdm==4.66.4

typing-inspect==0.9.0

typing_extensions==4.12.2

unstructured==0.14.8

unstructured-client==0.23.7

urllib3==2.2.2

wrapt==1.16.0

yarl==1.9.4

※ pip install langchain-community unstructured[md]

[PYTHON/COMMON] Lock 클래스 : 쓰레드에서 상호 배제 잠금 설정하기

■ Lock 클래스를 사용해 쓰레드에서 상호 배제 잠금을 설정하는 방법을 보여준다. ▶ 예제 코드 (PY)


from threading import Lock
from threading import Thread

class Counter:
    def __init__(self):
        self.lock  = Lock()
        self.count = 0

    def increment(self, value):
        with self.lock:
            self.count += value

def worker(loopCount, counter):
    for _ in range(loopCount):
        counter.increment(1)

def runThreads(sourceFunction, loopCount, counter):
    threadList = []
    for i in range(5):
        argumentTuple = (loopCount, counter)

        thread = Thread(target = sourceFunction, args = argumentTuple)

        threadList.append(thread)

        thread.start()

    for thread in threadList:
        thread.join()

loopCount = 10 ** 5
counter   = Counter()

runThreads(worker, loopCount, counter)

print("loopCount     :", loopCount    )
print("counter.count :", counter.count)

"""
loopCount     : 100000
counter.count : 500000
"""

from threading import Lock

from threading import Thread

class Counter:

def __init__(self):

self.lock = Lock()

self.count = 0

def increment(self, value):

with self.lock:

self.count += value

def worker(loopCount, counter):

for _ in range(loopCount):

counter.increment(1)

def runThreads(sourceFunction, loopCount, counter):

threadList = []

for i in range(5):

argumentTuple = (loopCount, counter)

thread = Thread(target = sourceFunction, args = argumentTuple)

threadList.append(thread)

thread.start()

for thread in threadList:

thread.join()

loopCount = 10 ** 5

counter = Counter()

runThreads(worker, loopCount, counter)

print("loopCount :", loopCount )

print("counter.count :", counter.count)

"""

loopCount : 100000

counter.count : 500000

"""

[PYTHON/COMMON] Thread 클래스 : start/join 메소드 사용하기

■ Thread 클래스의 start/join 메소드를 사용하는 방법을 보여준다. ▶ 예제 코드 (PY)


from threading import Lock
from threading import Thread

class Counter:
    def __init__(self):
        self.lock  = Lock()
        self.count = 0

    def increment(self, value):
        with self.lock:
            self.count += value

def worker(loopCount, counter):
    for _ in range(loopCount):
        counter.increment(1)

def runThreads(sourceFunction, loopCount, counter):
    threadList = []
    for i in range(5):
        argumentTuple = (loopCount, counter)

        thread = Thread(target = sourceFunction, args = argumentTuple)

        threadList.append(thread)

        thread.start()

    for thread in threadList:
        thread.join()

loopCount = 10 ** 5
counter   = Counter()

runThreads(worker, loopCount, counter)

print("loopCount     :", loopCount    )
print("counter.count :", counter.count)

"""
loopCount     : 100000
counter.count : 500000
"""

from threading import Lock

from threading import Thread

class Counter:

def __init__(self):

self.lock = Lock()

self.count = 0

def increment(self, value):

with self.lock:

self.count += value

def worker(loopCount, counter):

for _ in range(loopCount):

counter.increment(1)

def runThreads(sourceFunction, loopCount, counter):

threadList = []

for i in range(5):

argumentTuple = (loopCount, counter)

thread = Thread(target = sourceFunction, args = argumentTuple)

threadList.append(thread)

thread.start()

for thread in threadList:

thread.join()

loopCount = 10 ** 5

counter = Counter()

runThreads(worker, loopCount, counter)

print("loopCount :", loopCount )

print("counter.count :", counter.count)

"""

loopCount : 100000

counter.count : 500000

"""

[RUST/COMMON] spawn 함수 : 쓰레드로 병렬 계산 처리하기

■ spawn 함수를 사용해 쓰레드로 병렬 계산을 처리하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::sync::mpsc;
use std::thread;
use std::time;

fn main()
{
    let index_array : [i64; 7] = [43, 42, 20, 39, 37, 35, 30];

    let instant : time::Instant = time::Instant::now();

    let (tx, rx) = mpsc::channel::<(i64, i64)>();

    for index in index_array
    {
        let sender : mpsc::Sender<(i64, i64)> = tx.clone();

        thread::spawn
        (
            move ||
            {
                let fibonacci_sequence : i64 = calculate_fibonacci_sequence(index);

                sender.send((index, fibonacci_sequence)).unwrap();
            }
        );
    }

    let mut job_count : usize = index_array.len();

    loop
    {
        if let Ok((index, fibonacci_sequence)) = rx.recv()
        {
            job_count -= 1;

            println!("[결과] (남은 계산 : {}) {} 번째 피보나치 수 : {} ", job_count, index, fibonacci_sequence);

            if job_count <= 0
            {
                let duration : time::Duration = instant.elapsed();

                println!("실행 시간 : {:?}", duration);

                break;
            }
        }

        thread::sleep(time::Duration::from_millis(300));
    }
}

fn calculate_fibonacci_sequence(index : i64) -> i64
{
    if index == 1
    {
        return 0;
    }

    if index == 2
    {
        return 1;
    }

    return calculate_fibonacci_sequence(index - 2) + calculate_fibonacci_sequence(index - 1);
}

use std::sync::mpsc;

use std::thread;

use std::time;

fn main()

{

let index_array : [i64; 7] = [43, 42, 20, 39, 37, 35, 30];

let instant : time::Instant = time::Instant::now();

let (tx, rx) = mpsc::channel::<(i64, i64)>();

for index in index_array

{

let sender : mpsc::Sender<(i64, i64)> = tx.clone();

thread::spawn

(

move ||

{

let fibonacci_sequence : i64 = calculate_fibonacci_sequence(index);

sender.send((index, fibonacci_sequence)).unwrap();

}

);

}

let mut job_count : usize = index_array.len();

loop

{

if let Ok((index, fibonacci_sequence)) = rx.recv()

{

job_count -= 1;

println!("[결과] (남은 계산 : {}) {} 번째 피보나치 수 : {} ", job_count, index, fibonacci_sequence);

if job_count <= 0

{

let duration : time::Duration = instant.elapsed();

println!("실행 시간 : {:?}", duration);

break;

}

thread::sleep(time::Duration::from_millis(300));

}

fn calculate_fibonacci_sequence(index : i64) -> i64

{

if index == 1

{

return 0;

}

if index == 2

{

return 1;

}

return calculate_fibonacci_sequence(index - 2) + calculate_fibonacci_sequence(index - 1);

}

[RUST/COMMON] MPSC 채널 메커니즘을 사용해 스레드 간 데이터 공유하기

■ MPSC 채널 메커니즘을 사용해 스레드 간 데이터 공유하기 ▶ 예제 코드 (RS)


use std::sync::mpsc;
use std::thread;
use std::time;

fn send_message(source_message : &str, sender : mpsc::Sender<String>)
{
    let message_array : [&str; 5] = ["메시지 1", "메시지 2", "메시지 3", "메시지 4", "메시지 5"];

    for message in message_array
    {
        let target_message : String = format!("{} : {}", source_message, message);

        sender.send(target_message).unwrap();

        thread::sleep(time::Duration::from_millis(1000));
    }

    sender.send("중단".to_string()).unwrap();
}

fn main()
{
    let (tx, rx) = mpsc::channel::<String>();

    let sender1 : mpsc::Sender<String> = tx.clone();

    thread::spawn(|| { send_message("스레드 1", sender1); });

    let sender2 : mpsc::Sender<String> = tx.clone();

    thread::spawn(|| { send_message("스레드 2", sender2) });

    loop
    {
        let message : String = rx.recv().unwrap();

        println!("[수신] {}", message);

        if message == "중단"
        {
            break;
        }
    }
}

/*
[수신] 스레드 1 : 메시지 1
[수신] 스레드 2 : 메시지 1
[수신] 스레드 2 : 메시지 2
[수신] 스레드 1 : 메시지 2
[수신] 스레드 1 : 메시지 3
[수신] 스레드 2 : 메시지 3
[수신] 스레드 1 : 메시지 4
[수신] 스레드 2 : 메시지 4
[수신] 스레드 1 : 메시지 5
[수신] 스레드 2 : 메시지 5
[수신] 중단
*/

use std::sync::mpsc;

use std::thread;

use std::time;

fn send_message(source_message : &str, sender : mpsc::Sender<String>)

{

let message_array : [&str; 5] = ["메시지 1", "메시지 2", "메시지 3", "메시지 4", "메시지 5"];

for message in message_array

{

let target_message : String = format!("{} : {}", source_message, message);

sender.send(target_message).unwrap();

thread::sleep(time::Duration::from_millis(1000));

}

sender.send("중단".to_string()).unwrap();

}

fn main()

{

let (tx, rx) = mpsc::channel::<String>();

let sender1 : mpsc::Sender<String> = tx.clone();

thread::spawn(|| { send_message("스레드 1", sender1); });

let sender2 : mpsc::Sender<String> = tx.clone();

thread::spawn(|| { send_message("스레드 2", sender2) });

loop

{

let message : String = rx.recv().unwrap();

println!("[수신] {}", message);

if message == "중단"

{

break;

}

[수신] 스레드 1 : 메시지 1

[수신] 스레드 2 : 메시지 1

[수신] 스레드 2 : 메시지 2

[수신] 스레드 1 : 메시지 2

[수신] 스레드 1 : 메시지 3

[수신] 스레드 2 : 메시지 3

[수신] 스레드 1 : 메시지 4

[수신] 스레드 2 : 메시지 4

[수신] 스레드 1 : 메시지 5

[수신] 스레드 2 : 메시지 5

[수신] 중단

[RUST/COMMON] channel 함수 : MPSC 채널 객체 생성하기

■ channel 함수를 사용해 MPSC 채널 객체를 생성하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::sync::mpsc;

let (tx, rx) = mpsc::channel::<String>();

use std::sync::mpsc;

let (tx, rx) = mpsc::channel::<String>();

[RUST/COMMON] spawn 함수 : 쓰레드 생성하기

■ spawn 함수를 사용해 쓰레드를 생성하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::thread;
use std::time;

fn print_message(message : &str)
{
    for i in 1..=3
    {
        println!("{} : i = {}", message, i);

        thread::sleep(time::Duration::from_millis(1000));
    }
}

fn main()
{
    print_message("메인 스레드 1");

    thread::spawn(|| { print_message("스레드 1"); });

    thread::spawn(|| { print_message("스레드 2"); });

    thread::spawn(|| { print_message("스레드 3"); });

    print_message("메인 스레드 2");
}

/*
메인 스레드 1 : i = 1
메인 스레드 1 : i = 2
메인 스레드 1 : i = 3
메인 스레드 2 : i = 1
스레드 1 : i = 1
스레드 2 : i = 1
스레드 3 : i = 1
스레드 1 : i = 2
메인 스레드 2 : i = 2
스레드 3 : i = 2
스레드 2 : i = 2
메인 스레드 2 : i = 3
스레드 3 : i = 3
스레드 1 : i = 3
스레드 2 : i = 3
*/

use std::thread;

use std::time;

fn print_message(message : &str)

{

for i in 1..=3

{

println!("{} : i = {}", message, i);

thread::sleep(time::Duration::from_millis(1000));

}

fn main()

{

print_message("메인 스레드 1");

thread::spawn(|| { print_message("스레드 1"); });

thread::spawn(|| { print_message("스레드 2"); });

thread::spawn(|| { print_message("스레드 3"); });

print_message("메인 스레드 2");

}

메인 스레드 1 : i = 1

메인 스레드 1 : i = 2

메인 스레드 1 : i = 3

메인 스레드 2 : i = 1

스레드 1 : i = 1

스레드 2 : i = 1

스레드 3 : i = 1

스레드 1 : i = 2

메인 스레드 2 : i = 2

스레드 3 : i = 2

스레드 2 : i = 2

메인 스레드 2 : i = 3

스레드 3 : i = 3

스레드 1 : i = 3

스레드 2 : i = 3

[RUST/COMMON] sleep 함수 : 쓰레드 대기하기

■ sleep 함수를 사용해 쓰레드를 대기하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::thread;
use std::time;

thread::sleep(time::Duration::from_millis(1000));

use std::thread;

use std::time;

thread::sleep(time::Duration::from_millis(1000));

[C#/WPF] Thread 클래스 : CurrentThread 정적 속성을 사용해 문화 정보 설정하기

■ Thread 클래스의 CurrentThread 정적 속성을 사용해 특정 문화권을 설정하는 방법을 보여준다. ▶ MainApplication.xaml.cs


using System.Globalization;
using System.Threading;
using System.Windows;

namespace TestProject
{
    /// <summary>
    /// 메인 애플리케이션
    /// </summary>
    public partial class MainApplication : Application
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainApplication()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainApplication()
        {
            CultureInfo cultureInfo = new CultureInfo("fr-CA");

            Thread.CurrentThread.CurrentCulture   = cultureInfo;
            Thread.CurrentThread.CurrentUICulture = cultureInfo;
        }

        #endregion
    }
}

using System.Globalization;

using System.Threading;

using System.Windows;

namespace TestProject

{

/// <summary>

/// 메인 애플리케이션

/// </summary>

public partial class MainApplication : Application

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainApplication()

/// <summary>

/// 생성자

/// </summary>

public MainApplication()

{

CultureInfo cultureInfo = new CultureInfo("fr-CA");

Thread.CurrentThread.CurrentCulture = cultureInfo;

Thread.CurrentThread.CurrentUICulture = cultureInfo;

}

#endregion

}

[C#/WINFORM/.NET6] ISynchronizeInvoke 인터페이스 : InvokeRequired 코드 패턴 자동화하기

■ ISynchronizeInvoke 인터페이스를 사용해 InvokeRequired 코드 패턴을 자동화하는 방법을 보여준다. ▶ SynchronizeInvokeExtension.cs


using System.ComponentModel;

namespace TestProject;

/// <summary>
/// 호출 동기화 확장
/// </summary>
public static class SynchronizeInvokeExtension
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Method
    ////////////////////////////////////////////////////////////////////////////////////////// Static
    //////////////////////////////////////////////////////////////////////////////// Public

    #region 필요시 호출하기 - InvokeIfRequired<TTarget>(targetObject, action)

    /// <summary>
    /// 필요시 호출하기
    /// </summary>
    /// <typeparam name="TTarget">타겟 객체 타입</typeparam>
    /// <param name="targetObject">타겟 객체</param>
    /// <param name="action">액션</param>
    public static void InvokeIfRequired<TTarget>(this TTarget targetObject, Action<TTarget> action) where TTarget : ISynchronizeInvoke
    {
        if(targetObject.InvokeRequired)
        {
            targetObject.Invoke(action, new object[] { targetObject });
        }
        else
        {
            action(targetObject);
        }
    }

    #endregion
    #region 필요시 호출하기 - InvokeIfRequired<TTarget, TResult>(targetObject, function)

    /// <summary>
    /// 필요시 호출하기
    /// </summary>
    /// <typeparam name="TTarget">타겟 객체 타입</typeparam>
    /// <typeparam name="TResult">결과 타입</typeparam>
    /// <param name="targetObject">타겟 객체</param>
    /// <param name="function">함수</param>
    /// <returns>처리 결과</returns>
    public static TResult InvokeIfRequired<TTarget, TResult>(this TTarget targetObject, Func<TTarget, TResult> function) where TTarget : ISynchronizeInvoke
    {
        return targetObject.InvokeRequired ? (TResult)targetObject.Invoke(function, new object[] { targetObject }) : function(targetObject);
    }

    #endregion
}

using System.ComponentModel;

namespace TestProject;

/// <summary>

/// 호출 동기화 확장

/// </summary>

public static class SynchronizeInvokeExtension

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 필요시 호출하기 - InvokeIfRequired<TTarget>(targetObject, action)

/// <summary>

/// 필요시 호출하기

/// </summary>

/// <typeparam name="TTarget">타겟 객체 타입</typeparam>

/// <param name="targetObject">타겟 객체</param>

/// <param name="action">액션</param>

public static void InvokeIfRequired<TTarget>(this TTarget targetObject, Action<TTarget> action) where TTarget : ISynchronizeInvoke

{

if(targetObject.InvokeRequired)

{

targetObject.Invoke(action, new object[] { targetObject });

}

else

{

action(targetObject);

}

#endregion

#region 필요시 호출하기 - InvokeIfRequired<TTarget, TResult>(targetObject, function)

/// <summary>

/// 필요시 호출하기

/// </summary>

/// <typeparam name="TTarget">타겟 객체 타입</typeparam>

/// <typeparam name="TResult">결과 타입</typeparam>

/// <param name="targetObject">타겟 객체</param>

/// <param name="function">함수</param>

/// <returns>처리 결과</returns>

public static TResult InvokeIfRequired<TTarget, TResult>(this TTarget targetObject, Func<TTarget, TResult> function) where TTarget : ISynchronizeInvoke

{

return targetObject.InvokeRequired ? (TResult)targetObject.Invoke(function, new object[] { targetObject }) : function(targetObject);

}

#endregion

}

▶ MainForm.cs


namespace TestProject
{
    /// <summary>
    /// 메인 폼
    /// </summary>
    public partial class MainForm : Form
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainForm()
        {
            InitializeComponent();

            this.runButton.Click += runButton_Click;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private
        //////////////////////////////////////////////////////////////////////////////// Event

        #region 실행 버튼 클릭시 처리하기 - runButton_Click(sender, e)

        /// <summary>
        /// 실행 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void runButton_Click(object sender, EventArgs e)
        {
            Button button = sender as Button;

            button.Enabled = false;

            Thread thread = new Thread(new ThreadStart(ProcessThread));

            thread.Start();

        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////// Function

        #region 스레드 처리하기 - ProcessThread()

        /// <summary>
        /// 스레드 처리하기
        /// </summary>
        private void ProcessThread()
        {
            for(int i = 0; i < 10; i++)
            {
                this.InvokeIfRequired((form) => { this.messageLabel.Text = (i + 1).ToString(); });

                Thread.Sleep(500);
            }

            this.InvokeIfRequired
            (
                (form) =>
                {
                    this.messageLabel.Text = string.Empty;

                    this.runButton.Enabled = true;
                }
            );
        }

        #endregion
    }
}

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

this.runButton.Click += runButton_Click;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

//////////////////////////////////////////////////////////////////////////////// Event

#region 실행 버튼 클릭시 처리하기 - runButton_Click(sender, e)

/// <summary>

/// 실행 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void runButton_Click(object sender, EventArgs e)

{

Button button = sender as Button;

button.Enabled = false;

Thread thread = new Thread(new ThreadStart(ProcessThread));

thread.Start();

}

#endregion

//////////////////////////////////////////////////////////////////////////////// Function

#region 스레드 처리하기 - ProcessThread()

/// <summary>

/// 스레드 처리하기

/// </summary>

private void ProcessThread()

{

for(int i = 0; i < 10; i++)

{

this.InvokeIfRequired((form) => { this.messageLabel.Text = (i + 1).ToString(); });

Thread.Sleep(500);

}

this.InvokeIfRequired

(

(form) =>

{

this.messageLabel.Text = string.Empty;

this.runButton.Enabled = true;

}

);

}

#endregion

}

TestProject.zip

[C#/WINFORM/.NET6] MethodInvoker 대리자 : InvokeRequired 코드 패턴 자동화하기

■ MethodInvoker 대리자를 사용해 InvokeRequired 코드 패턴을 자동화하는 방법을 보여준다. ▶ ControlExtension.cs


namespace TestProject;

/// <summary>
/// 컨트롤 확장
/// </summary>
public static class ControlExtension
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Method
    ////////////////////////////////////////////////////////////////////////////////////////// Static
    //////////////////////////////////////////////////////////////////////////////// Public

    #region 필요시 호출하기 - InvokeIfRequired(control, methodInvoker)

    /// <summary>
    /// 필요시 호출하기
    /// </summary>
    /// <param name="control">컨트롤</param>
    /// <param name="methodInvoker">메소드 호출자</param>
    public static void InvokeIfRequired(this Control control, MethodInvoker methodInvoker)
    {
        if(control.InvokeRequired)
        {
            control.Invoke(methodInvoker);
        }
        else
        {
            methodInvoker();
        }
    }

    #endregion
}

namespace TestProject;

/// <summary>

/// 컨트롤 확장

/// </summary>

public static class ControlExtension

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 필요시 호출하기 - InvokeIfRequired(control, methodInvoker)

/// <summary>

/// 필요시 호출하기

/// </summary>

/// <param name="control">컨트롤</param>

/// <param name="methodInvoker">메소드 호출자</param>

public static void InvokeIfRequired(this Control control, MethodInvoker methodInvoker)

{

if(control.InvokeRequired)

{

control.Invoke(methodInvoker);

}

else

{

methodInvoker();

}

#endregion

}

▶ MainForm.cs


namespace TestProject
{
    /// <summary>
    /// 메인 폼
    /// </summary>
    public partial class MainForm : Form
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainForm()
        {
            InitializeComponent();

            this.runButton.Click += runButton_Click;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private
        //////////////////////////////////////////////////////////////////////////////// Event

        #region 실행 버튼 클릭시 처리하기 - runButton_Click(sender, e)

        /// <summary>
        /// 실행 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void runButton_Click(object sender, EventArgs e)
        {
            Button button = sender as Button;

            button.Enabled = false;

            Thread thread = new Thread(new ThreadStart(ProcessThread));

            thread.Start();

        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////// Function

        #region 스레드 처리하기 - ProcessThread()

        /// <summary>
        /// 스레드 처리하기
        /// </summary>
        private void ProcessThread()
        {
            for(int i = 0; i < 10; i++)
            {
                this.InvokeIfRequired(() => { this.messageLabel.Text = (i + 1).ToString(); });

                Thread.Sleep(500);
            }

            this.InvokeIfRequired
            (
                () =>
                {
                    this.messageLabel.Text = string.Empty;

                    this.runButton.Enabled = true;
                }
            );
        }

        #endregion
    }
}

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

this.runButton.Click += runButton_Click;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

//////////////////////////////////////////////////////////////////////////////// Event

#region 실행 버튼 클릭시 처리하기 - runButton_Click(sender, e)

/// <summary>

/// 실행 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void runButton_Click(object sender, EventArgs e)

{

Button button = sender as Button;

button.Enabled = false;

Thread thread = new Thread(new ThreadStart(ProcessThread));

thread.Start();

}

#endregion

//////////////////////////////////////////////////////////////////////////////// Function

#region 스레드 처리하기 - ProcessThread()

/// <summary>

/// 스레드 처리하기

/// </summary>

private void ProcessThread()

{

for(int i = 0; i < 10; i++)

{

this.InvokeIfRequired(() => { this.messageLabel.Text = (i + 1).ToString(); });

Thread.Sleep(500);

}

this.InvokeIfRequired

(

() =>

{

this.messageLabel.Text = string.Empty;

this.runButton.Enabled = true;

}

);

}

#endregion

}

TestProject.zip

[PYTHON/COMMON] Lock 클래스 : acquire/release 메소드 사용하기

■ Lock 클래스의 acquire/release 메소드를 사용하는 방법을 보여준다. ▶ 예제 코드 (PY)


import threading
import time

count = 10
lock  = threading.Lock()

class Developer(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name  = name
        self.fixed = 0

    def run(self):
        global count
        while True:
            lock.acquire()
            if count > 0:
                count -= 1
                lock.release()
                self.fixed += 1
                time.sleep(0.1)
            else:
                lock.release()
                break

developerList = []

for name in ["스레드1", "스레드2", "스레드3"]:
    devloper = Developer(name)
    developerList.append(devloper)
    devloper.start()

for devloper in developerList:
    devloper.join()
    print(devloper.name, "fixed", devloper.fixed)

"""
스레드1 fixed 3
스레드2 fixed 4
스레드3 fixed 3
"""

import threading

import time

count = 10

lock = threading.Lock()

class Developer(threading.Thread):

def __init__(self, name):

threading.Thread.__init__(self)

self.name = name

self.fixed = 0

def run(self):

global count

while True:

lock.acquire()

if count > 0:

count -= 1

lock.release()

self.fixed += 1

time.sleep(0.1)

else:

lock.release()

break

developerList = []

for name in ["스레드1", "스레드2", "스레드3"]:

devloper = Developer(name)

developerList.append(devloper)

devloper.start()

for devloper in developerList:

devloper.join()

print(devloper.name, "fixed", devloper.fixed)

"""

스레드1 fixed 3

스레드2 fixed 4

스레드3 fixed 3

"""

[C#/COMMON/.NET6] Interlocked 클래스 : Increment 정적 메소드를 사용해 스레드 안전 카운트 증가시키기

■ Interlocked 클래스의 Increment 정적 메소드를 사용해 스레드 안전 카운트를 증가시키는 방법을 보여준다. ▶ 예제 코드 (C#)


int count = 0;

Interlocked.Increment(ref count);

Console.WriteLine(count);

int count = 0;

Interlocked.Increment(ref count);

Console.WriteLine(count);

[C#/MAUI/.NET6] MainThread 클래스 : BeginInvokeOnMainThread 정적 메소드를 사용해 메인 스레드에서 실행하기

■ MainThread 클래스의 BeginInvokeOnMainThread 정적 메소드를 사용해 메인 스레드에서 실행하는 방법을 보여준다. ▶ 예제 코드 (C#)


/// <summary>
/// 실행하기
/// </summary>
private void Execute()
{
    // 작업을 한다.
}

...

if(MainThread.IsMainThread)
{
    Execute();
}
else
{
    MainThread.BeginInvokeOnMainThread(Execute);
}

/// <summary>

/// 실행하기

/// </summary>

private void Execute()

{

// 작업을 한다.

}

...

if(MainThread.IsMainThread)

{

Execute();

}

else

{

MainThread.BeginInvokeOnMainThread(Execute);

}

[C#/WINFORM] MethodInvoker 대리자 : 크로스 스레드(Cross Thread) 처리하기

■ MethodInvoker 대리자를 사용해 크로스 스레드(Cross Thread)를 처리하는 방법을 보여준다. ▶ MainForm.cs


using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace TestProject
{
    /// <summary>
    /// 메인 폼
    /// </summary>
    public partial class MainForm : Form
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainForm()
        {
            InitializeComponent();

            this.executeButton.Click += executeButton_Click;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private
        //////////////////////////////////////////////////////////////////////////////// Event

        #region 실행 버튼 클릭시 처리하기 - executeButton_Click(sender, e)

        /// <summary>
        /// 실행 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private async void executeButton_Click(object sender, EventArgs e)
        {
            this.executeButton.Enabled = false;

            await Task.Factory.StartNew(() => Execute());

            this.executeButton.Enabled = true;

            this.messageLabel.Text = string.Empty;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////// Function

        #region 실행하기 - Execute()

        /// <summary>
        /// 실행하기
        /// </summary>
        private void Execute()
        {
            for(int i = 0; i < 100; i++)
            {
                Invoke(new MethodInvoker(() => { this.messageLabel.Text = i.ToString(); }));

                Thread.Sleep(10);
            }
        }

        #endregion
    }
}

using System;

using System.Threading;

using System.Threading.Tasks;

using System.Windows.Forms;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

this.executeButton.Click += executeButton_Click;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

//////////////////////////////////////////////////////////////////////////////// Event

#region 실행 버튼 클릭시 처리하기 - executeButton_Click(sender, e)

/// <summary>

/// 실행 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private async void executeButton_Click(object sender, EventArgs e)

{

this.executeButton.Enabled = false;

await Task.Factory.StartNew(() => Execute());

this.executeButton.Enabled = true;

this.messageLabel.Text = string.Empty;

}

#endregion

//////////////////////////////////////////////////////////////////////////////// Function

#region 실행하기 - Execute()

/// <summary>

/// 실행하기

/// </summary>

private void Execute()

{

for(int i = 0; i < 100; i++)

{

Invoke(new MethodInvoker(() => { this.messageLabel.Text = i.ToString(); }));

Thread.Sleep(10);

}

#endregion

}

TestProject.zip

[C#/COMMON] Thread 클래스 : 특정 사용자 권한으로 스레드 실행하기

■ Thread 클래스를 사용해 특정 사용자 권한으로 스레드를 실행하는 방법을 보여준다. ▶ SECURITY_IMPERSONATION_LEVEL.cs


namespace TestProject
{
    /// <summary>
    /// 보안 가장 레벨
    /// </summary>
    public enum SECURITY_IMPERSONATION_LEVEL
    {
        /// <summary>
        /// SecurityAnonymous
        /// </summary>
        SecurityAnonymous = 0,

        /// <summary>
        /// SecurityIdentification
        /// </summary>
        SecurityIdentification = 1,

        /// <summary>
        /// SecurityImpersonation
        /// </summary>
        SecurityImpersonation = 2,

        /// <summary>
        /// SecurityDelegation
        /// </summary>
        SecurityDelegation = 3
    }
}

namespace TestProject

{

/// <summary>

/// 보안 가장 레벨

/// </summary>

public enum SECURITY_IMPERSONATION_LEVEL

{

/// <summary>

/// SecurityAnonymous

/// </summary>

SecurityAnonymous = 0,

/// <summary>

/// SecurityIdentification

/// </summary>

SecurityIdentification = 1,

/// <summary>

/// SecurityImpersonation

/// </summary>

SecurityImpersonation = 2,

/// <summary>

/// SecurityDelegation

/// </summary>

SecurityDelegation = 3

}

▶ TOKEN_TYPE.cs


namespace TestProject
{
    /// <summary>
    /// 토큰 타입
    /// </summary>
    public enum TOKEN_TYPE
    {
        /// <summary>
        /// TokenPrimary
        /// </summary>
        TokenPrimary = 1,

        /// <summary>
        /// TokenImpersonation
        /// </summary>
        TokenImpersonation = 2
    }
}

namespace TestProject

{

/// <summary>

/// 토큰 타입

/// </summary>

public enum TOKEN_TYPE

{

/// <summary>

/// TokenPrimary

/// </summary>

TokenPrimary = 1,

/// <summary>

/// TokenImpersonation

/// </summary>

TokenImpersonation = 2

}

▶ Program.cs


using System;
using System.Runtime.InteropServices;
using System.Security.Principal;
using System.Threading;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Import
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 사용자 로그온하기 - LogonUser(userName, domain, password, logonType, logonProvider, userToken)

        /// <summary>
        /// 사용자 로그온하기
        /// </summary>
        /// <param name="userName">사용자명</param>
        /// <param name="domain">도메인</param>
        /// <param name="password">패스워드</param>
        /// <param name="logonType">로그온 타입</param>
        /// <param name="logonProvider">로그온 공급자</param>
        /// <param name="userToken">사용자 토큰</param>
        /// <returns>처리 결과</returns>
        [DllImport("advapi32", EntryPoint = "LogonUser", SetLastError = true)]
        private static extern bool LogonUser(string userName, string domain, string password, int logonType, int logonProvider, out IntPtr userToken);

        #endregion
        #region 토큰 복제하기 (확장) - DuplicateTokenEx(existingTokenHandle, desiredAccess, threadAttributeHandle, tokenType, impersonationLevel, duplicateTokenHandle)

        /// <summary>
        /// 토큰 복제하기 (확장)
        /// </summary>
        /// <param name="existingTokenHandle">기존 토클 핸들</param>
        /// <param name="desiredAccess">희망 액세스</param>
        /// <param name="threadAttributeHandle">스레드 어트리뷰트 핸들</param>
        /// <param name="tokenType">토큰 타입</param>
        /// <param name="impersonationLevel">가장 레벨</param>
        /// <param name="duplicateTokenHandle">복제 토큰 핸들</param>
        /// <returns>처리 결과</returns>
        [DllImport("advapi32", EntryPoint = "DuplicateTokenEx")]
        private static extern bool DuplicateTokenEx
        (
            IntPtr     existingTokenHandle,
            uint       desiredAccess,
            IntPtr     threadAttributeHandle,
            int        tokenType,
            int        impersonationLevel,
            ref IntPtr duplicateTokenHandle
        );

        #endregion
        #region 스레드 토큰 설정하기 - SetThreadToken(threadHandle, tokenHandle)

        /// <summary>
        /// 스레드 토큰 설정하기
        /// </summary>
        /// <param name="threadHandle">스레드 핸들</param>
        /// <param name="tokenHandle">토큰 핸들</param>
        /// <returns>처리 결과</returns>
        [DllImport("advapi32", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool SetThreadToken(IntPtr threadHandle, IntPtr tokenHandle);

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            Console.WriteLine($"Main 함수 : {WindowsIdentity.GetCurrent().Name}");

            IntPtr userTokenHandle;

            LogonUser("user2", ".", "password2", 8, 0, out userTokenHandle);

            IntPtr copyUserTokenHandle = IntPtr.Zero;

            DuplicateTokenEx
            (
                userTokenHandle,
                0,
                IntPtr.Zero,
                (int)SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation,
                (int)TOKEN_TYPE.TokenImpersonation,
                ref copyUserTokenHandle
            );

            Thread thread = new Thread(new ParameterizedThreadStart(ExecuteThread));

            thread.Start(copyUserTokenHandle);
        }

        #endregion
        #region 스레드 실행하기 - ExecuteThread(parameter)

        /// <summary>
        /// 스레드 실행하기
        /// </summary>
        /// <param name="parameter">매개 변수</param>
        private static void ExecuteThread(object parameter)
        {
            IntPtr userTokenHandle = (IntPtr)parameter;

            SetThreadToken(IntPtr.Zero, userTokenHandle);

            WindowsIdentity windowsIdentity = WindowsIdentity.GetCurrent();

            Console.WriteLine($"ProcessThread 함수 : {WindowsIdentity.GetCurrent().Name}");
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

using System;

using System.Runtime.InteropServices;

using System.Security.Principal;

using System.Threading;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Import

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 사용자 로그온하기 - LogonUser(userName, domain, password, logonType, logonProvider, userToken)

/// <summary>

/// 사용자 로그온하기

/// </summary>

/// <param name="userName">사용자명</param>

/// <param name="domain">도메인</param>

/// <param name="password">패스워드</param>

/// <param name="logonType">로그온 타입</param>

/// <param name="logonProvider">로그온 공급자</param>

/// <param name="userToken">사용자 토큰</param>

/// <returns>처리 결과</returns>

[DllImport("advapi32", EntryPoint = "LogonUser", SetLastError = true)]

private static extern bool LogonUser(string userName, string domain, string password, int logonType, int logonProvider, out IntPtr userToken);

#endregion

#region 토큰 복제하기 (확장) - DuplicateTokenEx(existingTokenHandle, desiredAccess, threadAttributeHandle, tokenType, impersonationLevel, duplicateTokenHandle)

/// <summary>

/// 토큰 복제하기 (확장)

/// </summary>

/// <param name="existingTokenHandle">기존 토클 핸들</param>

/// <param name="desiredAccess">희망 액세스</param>

/// <param name="threadAttributeHandle">스레드 어트리뷰트 핸들</param>

/// <param name="tokenType">토큰 타입</param>

/// <param name="impersonationLevel">가장 레벨</param>

/// <param name="duplicateTokenHandle">복제 토큰 핸들</param>

/// <returns>처리 결과</returns>

[DllImport("advapi32", EntryPoint = "DuplicateTokenEx")]

private static extern bool DuplicateTokenEx

(

IntPtr existingTokenHandle,

uint desiredAccess,

IntPtr threadAttributeHandle,

int tokenType,

int impersonationLevel,

ref IntPtr duplicateTokenHandle

);

#endregion

#region 스레드 토큰 설정하기 - SetThreadToken(threadHandle, tokenHandle)

/// <summary>

/// 스레드 토큰 설정하기

/// </summary>

/// <param name="threadHandle">스레드 핸들</param>

/// <param name="tokenHandle">토큰 핸들</param>

/// <returns>처리 결과</returns>

[DllImport("advapi32", SetLastError = true)]

[return: MarshalAs(UnmanagedType.Bool)]

private static extern bool SetThreadToken(IntPtr threadHandle, IntPtr tokenHandle);

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

Console.WriteLine($"Main 함수 : {WindowsIdentity.GetCurrent().Name}");

IntPtr userTokenHandle;

LogonUser("user2", ".", "password2", 8, 0, out userTokenHandle);

IntPtr copyUserTokenHandle = IntPtr.Zero;

DuplicateTokenEx

(

userTokenHandle,

IntPtr.Zero,

(int)SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation,

(int)TOKEN_TYPE.TokenImpersonation,

ref copyUserTokenHandle

);

Thread thread = new Thread(new ParameterizedThreadStart(ExecuteThread));

thread.Start(copyUserTokenHandle);

}

#endregion

#region 스레드 실행하기 - ExecuteThread(parameter)

/// <summary>

/// 스레드 실행하기

/// </summary>

/// <param name="parameter">매개 변수</param>

private static void ExecuteThread(object parameter)

{

IntPtr userTokenHandle = (IntPtr)parameter;

SetThreadToken(IntPtr.Zero, userTokenHandle);

WindowsIdentity windowsIdentity = WindowsIdentity.GetCurrent();

Console.WriteLine($"ProcessThread 함수 : {WindowsIdentity.GetCurrent().Name}");

}

#endregion

}

TestProject.zip

[C#/COMMON] Process 클래스 : Threads 속성을 사용해 프로세스 스레드 정보 구하기

■ Process 클래스의 Threads 속성을 사용해 프로세스 스레드 정보를 구하는 방법을 보여준다. ▶ Program.cs


using System;
using System.Diagnostics;
using System.Linq;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            string machineName = Environment.MachineName;

            Process process = Process.GetProcesses(machineName).FirstOrDefault(p => p.ProcessName.Contains("chrome"));

            if(process != null)
            {
                foreach(ProcessThread thread in process.Threads)
                {
                    Console.WriteLine($"Thread ID         : {thread.Id           }");
                    Console.WriteLine($"Thread Start Time : {thread.StartTime    }");
                    Console.WriteLine($"Priority          : {thread.PriorityLevel}");
                }
            }
        }

        #endregion
    }
}

using System;

using System.Diagnostics;

using System.Linq;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

string machineName = Environment.MachineName;

Process process = Process.GetProcesses(machineName).FirstOrDefault(p => p.ProcessName.Contains("chrome"));

if(process != null)

{

foreach(ProcessThread thread in process.Threads)

{

Console.WriteLine($"Thread ID : {thread.Id }");

Console.WriteLine($"Thread Start Time : {thread.StartTime }");

Console.WriteLine($"Priority : {thread.PriorityLevel}");

}

#endregion

}

TestProject.zip

[C#/WPF] Dispatcher 클래스 : CheckAccess 메소드를 사용해 메인 스레드 여부 구하기

■ Dispatcher 클래스의 CheckAccess 메소드를 사용해 메인 스레드 여부를 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Windows;

#region 메인 스레드 여부 구하기 - IsMainThread()

/// <summary>
/// 메인 스레드 여부 구하기
/// </summary>
/// <returns>메인 스레드 여부</returns>
public bool IsMainThread()
{
    return Application.Current.Dispatcher.CheckAccess();
}

#endregion

using System.Windows;

#region 메인 스레드 여부 구하기 - IsMainThread()

/// <summary>

/// 메인 스레드 여부 구하기

/// </summary>

/// <returns>메인 스레드 여부</returns>

public bool IsMainThread()

{

return Application.Current.Dispatcher.CheckAccess();

}

#endregion

[C#/COMMON] Thread 클래스 : Interrupt 메소드를 사용해 스레드 종료하기

■ Thread 클래스의 Interrupt 메소드를 사용해 스레드를 종료하는 방법을 보여준다. ▶ Program.cs


using System;
using System.Threading;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            Thread thread = new Thread(ProcessThread);

            Console.WriteLine("START PROCESS THREAD");

            thread.Start();

            Thread.Sleep(2000);

            Console.WriteLine("FORCE TO TERMINATE THREAD");

            thread.Interrupt();

            thread.Join();

            Console.WriteLine("EXIT APPLICATION");
        }

        #endregion
        #region 스레드 처리하기 - ProcessThread()

        /// <summary>
        /// 스레드 처리하기
        /// </summary>
        private static void ProcessThread()
        {
            try
            {
                Thread.Sleep(10000);
            }
            catch(ThreadInterruptedException)
            {
                Console.WriteLine("THREAD INTERRUPTED EXCEPTION OCCURRED");

                return;
            }
        }

        #endregion
    }
}

using System;

using System.Threading;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

Thread thread = new Thread(ProcessThread);

Console.WriteLine("START PROCESS THREAD");

thread.Start();

Thread.Sleep(2000);

Console.WriteLine("FORCE TO TERMINATE THREAD");

thread.Interrupt();

thread.Join();

Console.WriteLine("EXIT APPLICATION");

}

#endregion

#region 스레드 처리하기 - ProcessThread()

/// <summary>

/// 스레드 처리하기

/// </summary>

private static void ProcessThread()

{

try

{

Thread.Sleep(10000);

}

catch(ThreadInterruptedException)

{

Console.WriteLine("THREAD INTERRUPTED EXCEPTION OCCURRED");

return;

}

#endregion

}

TestProject.zip

[C#/COMMON] ThreadPool 클래스 : QueueUserWorkItem 정적 메소드를 사용해 스레드 풀의 스레드 실행하기

■ ThreadPool 클래스의 QueueUserWorkItem 정적 메소드를 사용해 스레드 풀의 스레드를 실행하는 방법을 보여준다. ▶ Program.cs


using System;
using System.Threading;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 작업 처리하기 - ProcessJob(state)

        /// <summary>
        /// 작업 처리하기
        /// </summary>
        /// <param name="state">상태</param>
        private static void ProcessJob(object state)
        {
            ManualResetEvent manualResetEvent = state as ManualResetEvent;

            try
            {
                Console.WriteLine("작업 처리를 시작합니다.");

                Thread.Sleep(5000);

                Console.WriteLine("작업 처리를 종료합니다.");
            }
            finally
            {
                manualResetEvent.Set();
            }
        }

        #endregion
        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            ManualResetEvent manualResetEvent = new ManualResetEvent(false);

            if(ThreadPool.QueueUserWorkItem(ProcessJob, manualResetEvent))
            {
                manualResetEvent.WaitOne();

                Console.WriteLine("프로그램 실행을 종료합니다.");
            }
        }

        #endregion
    }
}

using System;

using System.Threading;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 작업 처리하기 - ProcessJob(state)

/// <summary>

/// 작업 처리하기

/// </summary>

/// <param name="state">상태</param>

private static void ProcessJob(object state)

{

ManualResetEvent manualResetEvent = state as ManualResetEvent;

try

{

Console.WriteLine("작업 처리를 시작합니다.");

Thread.Sleep(5000);

Console.WriteLine("작업 처리를 종료합니다.");

}

finally

{

manualResetEvent.Set();

}

#endregion

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

ManualResetEvent manualResetEvent = new ManualResetEvent(false);

if(ThreadPool.QueueUserWorkItem(ProcessJob, manualResetEvent))

{

manualResetEvent.WaitOne();

Console.WriteLine("프로그램 실행을 종료합니다.");

}

#endregion

}

[C#/COMMON] ThreadPool 클래스 : GetMinThreads 정적 메소드를 사용해 최소 스레드 수 설정하기

■ ThreadPool 클래스의 GetMinThreads 정적 메소드를 사용해 최소 스레드 수를 설정하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading;

int workerThreadCount, completionPortThreadCount;

ThreadPool.GetMinThreads(out workerThreadCount, out completionPortThreadCount);

Console.WriteLine("BEFORE UPDATE");
Console.WriteLine("--------------------------------------------------"           );
Console.WriteLine("WORKER THREAD COUNT          : {0}", workerThreadCount        );
Console.WriteLine("COMPLETION PORT THREAD COUNT : {0}", completionPortThreadCount);
Console.WriteLine("--------------------------------------------------"           );

Console.WriteLine();

ThreadPool.SetMinThreads(25, completionPortThreadCount);

ThreadPool.GetMinThreads(out workerThreadCount, out completionPortThreadCount);

Console.WriteLine("AFTER UPDATE");
Console.WriteLine("--------------------------------------------------"           );
Console.WriteLine("WORKER THREAD COUNT          : {0}", workerThreadCount        );
Console.WriteLine("COMPLETION PORT THREAD COUNT : {0}", completionPortThreadCount);
Console.WriteLine("--------------------------------------------------"           );

using System;

using System.Threading;

int workerThreadCount, completionPortThreadCount;

ThreadPool.GetMinThreads(out workerThreadCount, out completionPortThreadCount);

Console.WriteLine("BEFORE UPDATE");

Console.WriteLine("--------------------------------------------------" );

Console.WriteLine("WORKER THREAD COUNT : {0}", workerThreadCount );

Console.WriteLine("COMPLETION PORT THREAD COUNT : {0}", completionPortThreadCount);

Console.WriteLine("--------------------------------------------------" );

Console.WriteLine();

ThreadPool.SetMinThreads(25, completionPortThreadCount);

ThreadPool.GetMinThreads(out workerThreadCount, out completionPortThreadCount);

Console.WriteLine("AFTER UPDATE");

Console.WriteLine("--------------------------------------------------" );

Console.WriteLine("WORKER THREAD COUNT : {0}", workerThreadCount );

Console.WriteLine("COMPLETION PORT THREAD COUNT : {0}", completionPortThreadCount);

Console.WriteLine("--------------------------------------------------" );

[C#/WINFORM] SynchronizationContext 클래스 : 크로스 스레드(Cross Thread) 처리하기

■ SynchronizationContext 클래스를 사용해 크로스 스레드(Cross Thread)를 처리하는 방법을 보여준다. ▶ MainForm.cs


using System;
using System.Threading;
using System.Windows.Forms;

namespace TestProject
{
    /// <summary>
    /// 메인 폼
    /// </summary>
    public partial class MainForm : Form
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// 동기화 컨텍스트
        /// </summary>
        private SynchronizationContext context;

        /// <summary>
        /// 실행 여부
        /// </summary>
        private bool isRunning;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainForm()
        {
            InitializeComponent();

            this.context = SynchronizationContext.Current;

            this.isRunning = false;

            this.runButton.Click += runButton_Click;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private
        //////////////////////////////////////////////////////////////////////////////// Event

        #region 실행 버튼 클릭시 처리하기 - runButton_Click(sender, e)

        /// <summary>
        /// 실행 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void runButton_Click(object sender, EventArgs e)
        {
            if(this.isRunning)
            {
                return;
            }

            this.runButton.Enabled = false;

            this.isRunning = true;

            Thread thread = new Thread(ProcessThread);

            thread.Start();
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////// Function

        #region 스레드 처리하기 - ProcessThread()

        /// <summary>
        /// 스레드 처리하기
        /// </summary>
        private void ProcessThread()
        {
            this.context.Send
            (
                _ => {

                    this.messageLabel.Text = "처리를 시작합니다.";

                    this.progressBar.Value = 50;
                },
                null
            );

            Thread.Sleep(3000);

            this.context.Send
            (
                _ =>
                {
                    this.progressBar.Value = 100;

                    this.messageLabel.Text = "처리가 완료되었습니다.";

                    this.isRunning = false;

                    this.runButton.Enabled = true;
                },
                null
            );
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

using System;

using System.Threading;

using System.Windows.Forms;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// 동기화 컨텍스트

/// </summary>

private SynchronizationContext context;

/// <summary>

/// 실행 여부

/// </summary>

private bool isRunning;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

this.context = SynchronizationContext.Current;

this.isRunning = false;

this.runButton.Click += runButton_Click;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

//////////////////////////////////////////////////////////////////////////////// Event

#region 실행 버튼 클릭시 처리하기 - runButton_Click(sender, e)

/// <summary>

/// 실행 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void runButton_Click(object sender, EventArgs e)

{

if(this.isRunning)

{

return;

}

this.runButton.Enabled = false;

this.isRunning = true;

Thread thread = new Thread(ProcessThread);

thread.Start();

}

#endregion

//////////////////////////////////////////////////////////////////////////////// Function

#region 스레드 처리하기 - ProcessThread()

/// <summary>

/// 스레드 처리하기

/// </summary>

private void ProcessThread()

{

this.context.Send

(

_ => {

this.messageLabel.Text = "처리를 시작합니다.";

this.progressBar.Value = 50;

null

);

Thread.Sleep(3000);

this.context.Send

(

_ =>

{

this.progressBar.Value = 100;

this.messageLabel.Text = "처리가 완료되었습니다.";

this.isRunning = false;

this.runButton.Enabled = true;

null

);

}

#endregion

}

TestProject.zip

[C#/WPF] 복수 UI 스레드 윈도우 사용하기

■ 복수 UI 스레드 윈도우를 사용하는 방법을 보여준다. ▶ MainWindow.xaml


<Window x:Class="TestProject.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Width="800"
    Height="600"
    Title="TestProject"
    FontFamily="나눔고딕코딩"
    FontSize="16">
    <StackPanel>
        <StackPanel Margin="10" Orientation="Horizontal">
            <TextBlock Text="스레드 ID : "/>
            <TextBlock Text="{Binding ThreadId}" />
        </StackPanel>
        <Button Name="button"
            Width="200"
            Height="30"
            Content="새 윈도우 생성" />
    </StackPanel>
</Window>

<Window x:Class="TestProject.MainWindow"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Width="800"

Height="600"

Title="TestProject"

FontFamily="나눔고딕코딩"

FontSize="16">

</StackPanel>

<Button Name="button"

Width="200"

Height="30"

Content="새 윈도우 생성" />

</StackPanel>

</Window>

▶ MainWindow.xaml.cs


using System.Threading;
using System.Windows;

namespace TestProject
{
    /// <summary>
    /// 메인 윈도우
    /// </summary>
    public partial class MainWindow : Window
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainWindow()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainWindow()
        {
            InitializeComponent();

            Thread thread = Thread.CurrentThread;

            this.DataContext = new
            {
                ThreadId = thread.ManagedThreadId
            };

            this.button.Click += button_Click;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 새 윈도우 생성 버튼 클릭시 처리하기 - button_Click(sender, e)

        /// <summary>
        /// 새 윈도우 생성 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void button_Click(object sender, RoutedEventArgs e)
        {
            Thread thread = new Thread
            (
                () =>
                {
                    MainWindow window = new MainWindow();

                    window.Closed += (sender2, e2) => window.Dispatcher.InvokeShutdown();

                    window.Show();

                    System.Windows.Threading.Dispatcher.Run();
                }
            );

            thread.SetApartmentState(ApartmentState.STA);

            thread.Start();
        }

        #endregion
    }
}

using System.Threading;

using System.Windows;

namespace TestProject

{

/// <summary>

/// 메인 윈도우

/// </summary>

public partial class MainWindow : Window

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainWindow()

/// <summary>

/// 생성자

/// </summary>

public MainWindow()

{

InitializeComponent();

Thread thread = Thread.CurrentThread;

this.DataContext = new

{

ThreadId = thread.ManagedThreadId

};

this.button.Click += button_Click;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 새 윈도우 생성 버튼 클릭시 처리하기 - button_Click(sender, e)

/// <summary>

/// 새 윈도우 생성 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void button_Click(object sender, RoutedEventArgs e)

{

Thread thread = new Thread

(

() =>

{

MainWindow window = new MainWindow();

window.Closed += (sender2, e2) => window.Dispatcher.InvokeShutdown();

window.Show();

System.Windows.Threading.Dispatcher.Run();

}

);

thread.SetApartmentState(ApartmentState.STA);

thread.Start();

}

#endregion

}

TestProject.zip

[C#/WPF] Thread 클래스 사용하기

■ Thread 클래스를 사용하는 방법을 보여준다. ▶ MainWindow.xaml


<Window x:Class="TestProject.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Width="800"
    Height="600"
    Title="Thread 클래스 사용하기"
    FontFamily="나눔고딕코딩"
    FontSize="16">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="50*" />
            <RowDefinition Height="50*" />
        </Grid.RowDefinitions>
        <Button x:Name="button" Grid.Row="0"
            Width="100"
            Height="30"
            Content="테스트" />
        <TextBox x:Name="textBox" Grid.Row="1"
            Width="100"
            Height="25"
            HorizontalContentAlignment="Center"
            VerticalContentAlignment="Center"
            BorderBrush="Black"
            BorderThickness="1" />
    </Grid>
</Window>

<Window x:Class="TestProject.MainWindow"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Width="800"

Height="600"

Title="Thread 클래스 사용하기"

FontFamily="나눔고딕코딩"

FontSize="16">

<Grid>

<Grid.RowDefinitions>

</Grid.RowDefinitions>

<Button x:Name="button" Grid.Row="0"

Width="100"

Height="30"

Content="테스트" />

<TextBox x:Name="textBox" Grid.Row="1"

Width="100"

Height="25"

HorizontalContentAlignment="Center"

VerticalContentAlignment="Center"

BorderBrush="Black"

BorderThickness="1" />

</Grid>

</Window>

▶ MainWindow.xaml.cs


using System;
using System.Windows;
using System.Threading;
using System.Windows.Threading;

namespace TestProject
{
    /// <summary>
    /// 메인 윈도우
    /// </summary>
    public partial class MainWindow : Window
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainWindow()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainWindow()
        {
            InitializeComponent();

            this.button.Click += button_Click;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private
        //////////////////////////////////////////////////////////////////////////////// Event

        #region 테스트 버튼 클릭시 처리하기 - button_Click(sender, e)

        /// <summary>
        /// 테스트 버튼 클릭시 처리하기
        /// </summary>
        /// <param name="sender">이벤트 발생자</param>
        /// <param name="e">이벤트 인자</param>
        private void button_Click(object sender, RoutedEventArgs e)
        {
            IsEnabled = false;

            Thread thread = new Thread(new ThreadStart(ProcessTest));

            thread.Start();
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////// Function

        #region 테스트 처리하기 - ProcessTest()

        /// <summary>
        /// 테스트 처리하기
        /// </summary>
        private void ProcessTest()
        {

            for(int i = 1; i <= 10; i++)
            {
                Thread.Sleep(100);

                DispatcherOperation dispatcherOperation = Dispatcher.BeginInvoke
                (
                    DispatcherPriority.Normal,
                    new Action<string, int>
                    (
                        (message, value) => {
                            this.textBox.Text = string.Format("{0} : {1}", message, value);
                        }
                    ),
                    "테스트",
                    i
                );

                DispatcherOperationStatus dispatcherOperationStatus = dispatcherOperation.Status;

                while(dispatcherOperationStatus != DispatcherOperationStatus.Completed)
                {
                    dispatcherOperationStatus = dispatcherOperation.Wait(TimeSpan.FromMilliseconds(1000));

                    if(dispatcherOperationStatus == DispatcherOperationStatus.Aborted)
                    {
                        // Abort시 처리한다.
                    }
                }
            }

            Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(() => { IsEnabled = true; }));
        }

        #endregion
    }
}

using System;

using System.Windows;

using System.Threading;

using System.Windows.Threading;

namespace TestProject

{

/// <summary>

/// 메인 윈도우

/// </summary>

public partial class MainWindow : Window

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainWindow()

/// <summary>

/// 생성자

/// </summary>

public MainWindow()

{

InitializeComponent();

this.button.Click += button_Click;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

//////////////////////////////////////////////////////////////////////////////// Event

#region 테스트 버튼 클릭시 처리하기 - button_Click(sender, e)

/// <summary>

/// 테스트 버튼 클릭시 처리하기

/// </summary>

/// <param name="sender">이벤트 발생자</param>

/// <param name="e">이벤트 인자</param>

private void button_Click(object sender, RoutedEventArgs e)

{

IsEnabled = false;

Thread thread = new Thread(new ThreadStart(ProcessTest));

thread.Start();

}

#endregion

//////////////////////////////////////////////////////////////////////////////// Function

#region 테스트 처리하기 - ProcessTest()

/// <summary>

/// 테스트 처리하기

/// </summary>

private void ProcessTest()

{

for(int i = 1; i <= 10; i++)

{

Thread.Sleep(100);

DispatcherOperation dispatcherOperation = Dispatcher.BeginInvoke

(

DispatcherPriority.Normal,

new Action<string, int>

(

(message, value) => {

this.textBox.Text = string.Format("{0} : {1}", message, value);

}

"테스트",

);

DispatcherOperationStatus dispatcherOperationStatus = dispatcherOperation.Status;

while(dispatcherOperationStatus != DispatcherOperationStatus.Completed)

{

dispatcherOperationStatus = dispatcherOperation.Wait(TimeSpan.FromMilliseconds(1000));

if(dispatcherOperationStatus == DispatcherOperationStatus.Aborted)

{

// Abort시 처리한다.

}

Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(() => { IsEnabled = true; }));

}

#endregion

}

TestProject.zip

[C#/COMMON] 스레드 안전 우선 순위 큐 만들기

■ 스레드 안전 우선 순위 큐를 만드는 방법을 보여준다. ▶ ThreadSafeSortedList.cs


using System;
using System.Collections.Generic;

namespace TestProject
{
    /// <summary>
    /// 스레드 안전 정렬 리스트
    /// </summary>
    /// <typeparam name="TItemKey">항목 키 타입</typeparam>
    /// <typeparam name="TItem">항목 타입</typeparam>
    public class ThreadSafeSortedList<TItemKey, TItem> : SortedList<TItemKey, TItem>
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Protected

        #region Field

        /// <summary>
        /// 동기 객체
        /// </summary>
        protected object syncObject;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Property
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 카운트 - Count

        /// <summary>
        /// 카운트
        /// </summary>
        public new int Count
        {
            get
            {
                lock(this.syncObject)
                {
                    return base.Count;
                }
            }
        }

        #endregion
        #region 인덱서 - this[itemKey]

        /// <summary>
        /// 인덱서
        /// </summary>
        /// <param name="itemKey">항목 키</param>
        /// <returns>항목</returns>
        public new TItem this[TItemKey itemKey]
        {
            get
            {
                lock(this.syncObject)
                {
                    return base[itemKey];
                }
            }
            set
            {
                lock(this.syncObject)
                {
                    base[itemKey] = value;
                }
            }
        }

        #endregion
        #region 인덱서 - this[itemKeyIndex]

        /// <summary>
        /// 인덱서
        /// </summary>
        /// <param name="itemKeyIndex">항목 키 인덱스</param>
        /// <returns>항목</returns>
        public TItem this[int itemKeyIndex]
        {
            get
            {
                lock(this.syncObject)
                {
                    TItemKey itemKey = base.Keys[itemKeyIndex];

                    return base[itemKey];
                }
            }
            set
            {
                lock(this.syncObject)
                {
                    TItemKey itemKey = base.Keys[itemKeyIndex];

                    base[itemKey] = value;
                }
            }
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - ThreadSafeSortedList()

        /// <summary>
        /// 생성자
        /// </summary>
        public ThreadSafeSortedList()
        {
            this.syncObject = new Object();
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 항목 키 포함 여부 구하기 - ContainsItemKey(itemKey)

        /// <summary>
        /// 항목 키 포함 여부 구하기
        /// </summary>
        /// <param name="itemKey">항목 키</param>
        /// <returns>항목 키 포함 여부</returns>
        public bool ContainsItemKey(TItemKey itemKey)
        {
            lock(this.syncObject)
            {
                return base.ContainsKey(itemKey);
            }
        }

        #endregion
        #region 항목 추가하기 - AddItem(itemKey, item)

        /// <summary>
        /// 항목 추가하기
        /// </summary>
        /// <param name="itemKey">항목 키</param>
        /// <param name="item">항목</param>
        /// <returns>처리 결과</returns>
        public bool AddItem(TItemKey itemKey, TItem item)
        {
            lock(this.syncObject)
            {
                if(base.ContainsKey(itemKey))
                {
                    return false;
                }
                else
                {
                    base.Add(itemKey, item);

                    return true;
                }
            }
        }

        #endregion
        #region 항목 제거하기 - RemoveItemAt(index)

        /// <summary>
        /// 항목 제거하기
        /// </summary>
        /// <param name="index">인덱스</param>
        public void RemoveItemAt(int index)
        {
            lock(this.syncObject)
            {
                RemoveAt(index);
            }
        }

        #endregion
        #region 항목 제거하기 - RemoveItem(itemKey)

        /// <summary>
        /// 항목 제거하기
        /// </summary>
        /// <param name="itemKey">항목 키</param>
        /// <returns>처리 결과</returns>
        public bool RemoveItem(TItemKey itemKey)
        {
            lock(this.syncObject)
            {
                return base.Remove(itemKey);
            }
        }

        #endregion
        #region 데이터 제거하기 - ClearData()

        /// <summary>
        /// 데이터 제거하기
        /// </summary>
        public void ClearData()
        {
            lock(this.syncObject)
            {
                Clear();
            }
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

using System;

using System.Collections.Generic;

namespace TestProject

{

/// <summary>

/// 스레드 안전 정렬 리스트

/// </summary>

/// <typeparam name="TItemKey">항목 키 타입</typeparam>

/// <typeparam name="TItem">항목 타입</typeparam>

public class ThreadSafeSortedList<TItemKey, TItem> : SortedList<TItemKey, TItem>

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Protected

#region Field

/// <summary>

/// 동기 객체

/// </summary>

protected object syncObject;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 카운트 - Count

/// <summary>

/// 카운트

/// </summary>

public new int Count

{

get

{

lock(this.syncObject)

{

return base.Count;

}

#endregion

#region 인덱서 - this[itemKey]

/// <summary>

/// 인덱서

/// </summary>

/// <param name="itemKey">항목 키</param>

/// <returns>항목</returns>

public new TItem this[TItemKey itemKey]

{

get

{

lock(this.syncObject)

{

return base[itemKey];

}

set

{

lock(this.syncObject)

{

base[itemKey] = value;

}

#endregion

#region 인덱서 - this[itemKeyIndex]

/// <summary>

/// 인덱서

/// </summary>

/// <param name="itemKeyIndex">항목 키 인덱스</param>

/// <returns>항목</returns>

public TItem this[int itemKeyIndex]

{

get

{

lock(this.syncObject)

{

TItemKey itemKey = base.Keys[itemKeyIndex];

return base[itemKey];

}

set

{

lock(this.syncObject)

{

TItemKey itemKey = base.Keys[itemKeyIndex];

base[itemKey] = value;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - ThreadSafeSortedList()

/// <summary>

/// 생성자

/// </summary>

public ThreadSafeSortedList()

{

this.syncObject = new Object();

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 항목 키 포함 여부 구하기 - ContainsItemKey(itemKey)

/// <summary>

/// 항목 키 포함 여부 구하기

/// </summary>

/// <param name="itemKey">항목 키</param>

/// <returns>항목 키 포함 여부</returns>

public bool ContainsItemKey(TItemKey itemKey)

{

lock(this.syncObject)

{

return base.ContainsKey(itemKey);

}

#endregion

#region 항목 추가하기 - AddItem(itemKey, item)

/// <summary>

/// 항목 추가하기

/// </summary>

/// <param name="itemKey">항목 키</param>

/// <param name="item">항목</param>

/// <returns>처리 결과</returns>

public bool AddItem(TItemKey itemKey, TItem item)

{

lock(this.syncObject)

{

if(base.ContainsKey(itemKey))

{

return false;

}

else

{

base.Add(itemKey, item);

return true;

}

#endregion

#region 항목 제거하기 - RemoveItemAt(index)

/// <summary>

/// 항목 제거하기

/// </summary>

/// <param name="index">인덱스</param>

public void RemoveItemAt(int index)

{

lock(this.syncObject)

{

RemoveAt(index);

}

#endregion

#region 항목 제거하기 - RemoveItem(itemKey)

/// <summary>

/// 항목 제거하기

/// </summary>

/// <param name="itemKey">항목 키</param>

/// <returns>처리 결과</returns>

public bool RemoveItem(TItemKey itemKey)

{

lock(this.syncObject)

{

return base.Remove(itemKey);

}

#endregion

#region 데이터 제거하기 - ClearData()

/// <summary>

/// 데이터 제거하기

/// </summary>

public void ClearData()

{

lock(this.syncObject)

{

Clear();

}

#endregion

}

▶ ThreadSafeSortedListQueue.cs


namespace TestProject
{
    /// <summary>
    /// 스레드 안전 정렬 리스트 큐
    /// </summary>
    /// <typeparam name="TItemKey">항목 키 타입</typeparam>
    /// <typeparam name="TItem">항목 타입</typeparam>
    public class ThreadSafeSortedListQueue<TItemKey, TItem> : ThreadSafeSortedList<TItemKey, TItem>
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 항목 넣기 - EnqueueItem(itemKey, item)

        /// <summary>
        /// 항목 넣기
        /// </summary>
        /// <param name="itemKey">항목 키</param>
        /// <param name="item">항목</param>
        /// <returns>처리 결과</returns>
        public bool EnqueueItem(TItemKey itemKey, TItem item)
        {
            return AddItem(itemKey, item);
        }

        #endregion
        #region 항목 엿보기 - PeekItem()

        /// <summary>
        /// 항목 엿보기
        /// </summary>
        /// <returns>항목</returns>
        public TItem PeekItem()
        {
            lock(this.syncObject)
            {
                if(base.Count > 0)
                {
                    return this[0];
                }
                else
                {
                    return default(TItem);
                }
            }
        }

        #endregion
        #region 항목 꺼내기 - DequeueItem()

        /// <summary>
        /// 항목 꺼내기
        /// </summary>
        /// <returns>항목</returns>
        public TItem DequeueItem()
        {
            lock(this.syncObject)
            {
                if(Count > 0)
                {
                    TItem item = this[0];

                    base.RemoveAt(0);

                    return item;
                }
                else
                {
                    return default(TItem);
                }
            }
        }

        #endregion
    }
}

namespace TestProject

{

/// <summary>

/// 스레드 안전 정렬 리스트 큐

/// </summary>

/// <typeparam name="TItemKey">항목 키 타입</typeparam>

/// <typeparam name="TItem">항목 타입</typeparam>

public class ThreadSafeSortedListQueue<TItemKey, TItem> : ThreadSafeSortedList<TItemKey, TItem>

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 항목 넣기 - EnqueueItem(itemKey, item)

/// <summary>

/// 항목 넣기

/// </summary>

/// <param name="itemKey">항목 키</param>

/// <param name="item">항목</param>

/// <returns>처리 결과</returns>

public bool EnqueueItem(TItemKey itemKey, TItem item)

{

return AddItem(itemKey, item);

}

#endregion

#region 항목 엿보기 - PeekItem()

/// <summary>

/// 항목 엿보기

/// </summary>

/// <returns>항목</returns>

public TItem PeekItem()

{

lock(this.syncObject)

{

if(base.Count > 0)

{

return this[0];

}

else

{

return default(TItem);

}

#endregion

#region 항목 꺼내기 - DequeueItem()

/// <summary>

/// 항목 꺼내기

/// </summary>

/// <returns>항목</returns>

public TItem DequeueItem()

{

lock(this.syncObject)

{

if(Count > 0)

{

TItem item = this[0];

base.RemoveAt(0);

return item;

}

else

{

return default(TItem);

}

#endregion

}

▶ IKeyMessage.cs


namespace TestProject
{
    /// <summary>
    /// 키 메시지 인터페이스
    /// </summary>
    public interface IKeyMessage<TItemKey>
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Property

        #region 키 - Key

        /// <summary>
        /// 키
        /// </summary>
        TItemKey Key { get; set; }

        #endregion
    }
}

namespace TestProject

{

/// <summary>

/// 키 메시지 인터페이스

/// </summary>

public interface IKeyMessage<TItemKey>

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

#region 키 - Key

/// <summary>

/// 키

/// </summary>

TItemKey Key { get; set; }

#endregion

}

▶ IPriorityMessage.cs


namespace TestProject
{
    /// <summary>
    /// 우선 순위 메시지 인터페이스
    /// </summary>
    public interface IPriorityMessage
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Property

        #region 우선 순위 - Priority

        /// <summary>
        /// 우선 순위
        /// </summary>
        int Priority { get; set; }

        #endregion
    }
}

namespace TestProject

{

/// <summary>

/// 우선 순위 메시지 인터페이스

/// </summary>

public interface IPriorityMessage

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

#region 우선 순위 - Priority

/// <summary>

/// 우선 순위

/// </summary>

int Priority { get; set; }

#endregion

}

▶