CONCURRENCY Archives - 15 중 14 번째 페이지

[C#/COMMON] ThreadPool 클래스 : RegisterWaitForSingleObject 메소드를 사용해 타임아웃 사용하기

■ ThreadPool 클래스의 RegisterWaitForSingleObject 메소드를 사용해 타임아웃을 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading;

...

#region 대기 또는 타이머 콜백 처리하기 - WaitOrTimerCallback(cancellationTokenSource, isTimedOut)

/// <summary>
/// 대기 또는 타이머 콜백 처리하기
/// </summary>
/// <param name="cancellationTokenSource">취소 토큰 소스</param>
/// <param name="isTimedOut">타임아웃 여부</param>
private void WaitOrTimerCallback(CancellationTokenSource cancellationTokenSource, bool isTimedOut)
{
    if(isTimedOut)
    {
        cancellationTokenSource.Cancel();

        Console.WriteLine("타임아웃으로 테스트 처리가 취소되었습니다.");
    }
    else
    {
        Console.WriteLine("테스트가 완료되었습니다.");
    }
}

#endregion
#region 테스트 처리하기 - Test(cancellationToken, manualResetEvent)

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="cancellationToken">취소 토큰</param>
/// <param name="manualResetEvent">수동 리셋 이벤트</param>
private void Test(CancellationToken cancellationToken, ManualResetEvent manualResetEvent)
{
    for(int i = 0; i < 6; i++)
    {
        if(cancellationToken.IsCancellationRequested)
        {
            return;
        }

        Thread.Sleep(TimeSpan.FromSeconds(1));
    }

    manualResetEvent.Set();
}

#endregion
#region 테스트 실행하기 - ExecuteTest(timeoutTimeSpan)

/// <summary>
/// 테스트 실행하기
/// </summary>
/// <param name="timeoutTimeSpan">타임아웃 시간</param>
private void ExecuteTest(TimeSpan timeoutTimeSpan)
{
    using(ManualResetEvent manualResetEvent = new ManualResetEvent(false))
    {
        using(CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
        {
            Console.WriteLine("타임아웃 작업을 등록합니다...");

            RegisteredWaitHandle registeredWaitHandle = ThreadPool.RegisterWaitForSingleObject
            (
                manualResetEvent,
                (state, isTimedOut) => WaitOrTimerCallback(cancellationTokenSource, isTimedOut),
                null,
                timeoutTimeSpan,
                true
            );

            Console.WriteLine("긴 실행 작업을 시작합니다...");

            ThreadPool.QueueUserWorkItem(_ => Test(cancellationTokenSource.Token, manualResetEvent));

            Thread.Sleep(timeoutTimeSpan.Add(TimeSpan.FromSeconds(2)));

            registeredWaitHandle.Unregister(manualResetEvent);
        }
    }
}

#endregion

...

ExecuteTest(TimeSpan.FromSeconds(5));
ExecuteTest(TimeSpan.FromSeconds(7));

using System;

using System.Threading;

...

#region 대기 또는 타이머 콜백 처리하기 - WaitOrTimerCallback(cancellationTokenSource, isTimedOut)

/// <summary>

/// 대기 또는 타이머 콜백 처리하기

/// </summary>

/// <param name="cancellationTokenSource">취소 토큰 소스</param>

/// <param name="isTimedOut">타임아웃 여부</param>

private void WaitOrTimerCallback(CancellationTokenSource cancellationTokenSource, bool isTimedOut)

{

if(isTimedOut)

{

cancellationTokenSource.Cancel();

Console.WriteLine("타임아웃으로 테스트 처리가 취소되었습니다.");

}

else

{

Console.WriteLine("테스트가 완료되었습니다.");

}

#endregion

#region 테스트 처리하기 - Test(cancellationToken, manualResetEvent)

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="cancellationToken">취소 토큰</param>

/// <param name="manualResetEvent">수동 리셋 이벤트</param>

private void Test(CancellationToken cancellationToken, ManualResetEvent manualResetEvent)

{

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

{

if(cancellationToken.IsCancellationRequested)

{

return;

}

Thread.Sleep(TimeSpan.FromSeconds(1));

}

manualResetEvent.Set();

}

#endregion

#region 테스트 실행하기 - ExecuteTest(timeoutTimeSpan)

/// <summary>

/// 테스트 실행하기

/// </summary>

/// <param name="timeoutTimeSpan">타임아웃 시간</param>

private void ExecuteTest(TimeSpan timeoutTimeSpan)

{

using(ManualResetEvent manualResetEvent = new ManualResetEvent(false))

{

using(CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())

{

Console.WriteLine("타임아웃 작업을 등록합니다...");

RegisteredWaitHandle registeredWaitHandle = ThreadPool.RegisterWaitForSingleObject

(

manualResetEvent,

(state, isTimedOut) => WaitOrTimerCallback(cancellationTokenSource, isTimedOut),

null,

timeoutTimeSpan,

true

);

Console.WriteLine("긴 실행 작업을 시작합니다...");

ThreadPool.QueueUserWorkItem(_ => Test(cancellationTokenSource.Token, manualResetEvent));

Thread.Sleep(timeoutTimeSpan.Add(TimeSpan.FromSeconds(2)));

registeredWaitHandle.Unregister(manualResetEvent);

}

#endregion

...

ExecuteTest(TimeSpan.FromSeconds(5));

ExecuteTest(TimeSpan.FromSeconds(7));

[C#/COMMON] ThreadPool 클래스 : 취소 옵션 사용하기

■ ThreadPool 클래스에서 취소 옵션을 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading;

...

#region 첫번째 테스트 처리하기 - Test1(cancellationToken)

/// <summary>
/// 첫번째 테스트 처리하기
/// </summary>
/// <param name="cancellationToken">취소 토큰</param>
private void Test1(CancellationToken cancellationToken)
{
    Console.WriteLine("첫번째 테스트 처리를 시작합니다...");

    for(int i = 0; i < 5; i++)
    {
        if(cancellationToken.IsCancellationRequested)
        {
            Console.WriteLine("첫번째 테스트 처리가 취소되었습니다.");

            return;
        }

        Thread.Sleep(TimeSpan.FromSeconds(1));
    }

    Console.WriteLine("첫번째 테스트 처리를 종료합니다...");
}

#endregion
#region 두번째 테스트 처리하기 - Test2(cancellationToken)

/// <summary>
/// 두번째 테스트 처리하기
/// </summary>
/// <param name="cancellationToken">취소 토큰</param>
private void Test2(CancellationToken cancellationToken)
{
    try
    {
        Console.WriteLine("두번째 테스트 처리를 시작합니다...");

        for(int i = 0; i < 5; i++)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Thread.Sleep(TimeSpan.FromSeconds(1));
        }

        Console.WriteLine("두번째 테스트 처리를 종료합니다...");
    }
    catch(OperationCanceledException)
    {
        Console.WriteLine("두번째 테스트 처리가 취소되었습니다.");
    }
}

#endregion
#region 세번째 테스트 처리하기 - Test3(cancellationToken)

/// <summary>
/// 세번째 테스트 처리하기
/// </summary>
/// <param name="cancellationToken">취소 토큰</param>
private void Test3(CancellationToken cancellationToken)
{
    bool cancellationFlag = false;

    cancellationToken.Register(() => cancellationFlag = true);

    Console.WriteLine("세번째 테스트 처리를 시작합니다...");

    for(int i = 0; i < 5; i++)
    {
        if(cancellationFlag)
        {
            Console.WriteLine("세번째 테스트 처리가 취소되었습니다.");

            return;
        }

        Thread.Sleep(TimeSpan.FromSeconds(1));
    }

    Console.WriteLine("세번째 테스트 처리를 종료합니다...");
}

#endregion

...

using(CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
{
    CancellationToken cancellationToken = cancellationTokenSource.Token;

    ThreadPool.QueueUserWorkItem(_ => Test1(cancellationToken));

    Thread.Sleep(TimeSpan.FromSeconds(2));

    cancellationTokenSource.Cancel();
}

using(CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
{
    CancellationToken cancellationToken = cancellationTokenSource.Token;

    ThreadPool.QueueUserWorkItem(_ => Test2(cancellationToken));

    Thread.Sleep(TimeSpan.FromSeconds(2));

    cancellationTokenSource.Cancel();
}

using(CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
{
    CancellationToken cancellationToken = cancellationTokenSource.Token;

    ThreadPool.QueueUserWorkItem(_ => Test3(cancellationToken));

    Thread.Sleep(TimeSpan.FromSeconds(2));

    cancellationTokenSource.Cancel();
}

Thread.Sleep(TimeSpan.FromSeconds(2));

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

using System;

using System.Threading;

...

#region 첫번째 테스트 처리하기 - Test1(cancellationToken)

/// <summary>

/// 첫번째 테스트 처리하기

/// </summary>

/// <param name="cancellationToken">취소 토큰</param>

private void Test1(CancellationToken cancellationToken)

{

Console.WriteLine("첫번째 테스트 처리를 시작합니다...");

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

{

if(cancellationToken.IsCancellationRequested)

{

Console.WriteLine("첫번째 테스트 처리가 취소되었습니다.");

return;

}

Thread.Sleep(TimeSpan.FromSeconds(1));

}

Console.WriteLine("첫번째 테스트 처리를 종료합니다...");

}

#endregion

#region 두번째 테스트 처리하기 - Test2(cancellationToken)

/// <summary>

/// 두번째 테스트 처리하기

/// </summary>

/// <param name="cancellationToken">취소 토큰</param>

private void Test2(CancellationToken cancellationToken)

{

try

{

Console.WriteLine("두번째 테스트 처리를 시작합니다...");

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

{

cancellationToken.ThrowIfCancellationRequested();

Thread.Sleep(TimeSpan.FromSeconds(1));

}

Console.WriteLine("두번째 테스트 처리를 종료합니다...");

}

catch(OperationCanceledException)

{

Console.WriteLine("두번째 테스트 처리가 취소되었습니다.");

}

#endregion

#region 세번째 테스트 처리하기 - Test3(cancellationToken)

/// <summary>

/// 세번째 테스트 처리하기

/// </summary>

/// <param name="cancellationToken">취소 토큰</param>

private void Test3(CancellationToken cancellationToken)

{

bool cancellationFlag = false;

cancellationToken.Register(() => cancellationFlag = true);

Console.WriteLine("세번째 테스트 처리를 시작합니다...");

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

{

if(cancellationFlag)

{

Console.WriteLine("세번째 테스트 처리가 취소되었습니다.");

return;

}

Thread.Sleep(TimeSpan.FromSeconds(1));

}

Console.WriteLine("세번째 테스트 처리를 종료합니다...");

}

#endregion

...

using(CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())

{

CancellationToken cancellationToken = cancellationTokenSource.Token;

ThreadPool.QueueUserWorkItem(_ => Test1(cancellationToken));

Thread.Sleep(TimeSpan.FromSeconds(2));

cancellationTokenSource.Cancel();

}

using(CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())

{

CancellationToken cancellationToken = cancellationTokenSource.Token;

ThreadPool.QueueUserWorkItem(_ => Test2(cancellationToken));

Thread.Sleep(TimeSpan.FromSeconds(2));

cancellationTokenSource.Cancel();

}

using(CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())

{

CancellationToken cancellationToken = cancellationTokenSource.Token;

ThreadPool.QueueUserWorkItem(_ => Test3(cancellationToken));

Thread.Sleep(TimeSpan.FromSeconds(2));

cancellationTokenSource.Cancel();

}

Thread.Sleep(TimeSpan.FromSeconds(2));

[C#/COMMON] ThreadPool 클래스 : 비동기 호출하기

■ ThreadPool 클래스를 사용해 비동기 호출하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading;

...

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

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="parameter">매개 변수</param>
private void Test(object parameter)
{
    int threadID = Thread.CurrentThread.ManagedThreadId;

    Console.WriteLine("[{0} 스레드] 테스트 처리를 시작합니다...", threadID);

    Console.WriteLine("[{0} 스레드] 매개 변수 : {1}", threadID, parameter ?? "(null)");

    Thread.Sleep(TimeSpan.FromSeconds(2));

    Console.WriteLine("[{0} 스레드] 테스트 종료를 시작합니다...", threadID);
}

#endregion

...

ThreadPool.QueueUserWorkItem(Test);

Thread.Sleep(TimeSpan.FromSeconds(1));

ThreadPool.QueueUserWorkItem(Test, "테스트 #2");

Thread.Sleep(TimeSpan.FromSeconds(1));

ThreadPool.QueueUserWorkItem
(
    parameter =>
    {
        int threadID = Thread.CurrentThread.ManagedThreadId;

        Console.WriteLine("[{0} 스레드] 람다 표현식 처리를 시작합니다...", threadID);

        Console.WriteLine("[{0} 스레드] 매개 변수 : {1}", threadID, parameter);

        Thread.Sleep(TimeSpan.FromSeconds(2));

        Console.WriteLine("[{0} 스레드] 람다 표현식 처리를 종료합니다...", threadID);
    },
    "테스트 #3"
);

const int    x              = 1;
const int    y              = 2;
const string outerParameter = "테스트 #4";

ThreadPool.QueueUserWorkItem
(
    _ =>
    {
        int threadID = Thread.CurrentThread.ManagedThreadId;

        Console.WriteLine("[{0} 스레드] 람다 표현식 처리를 시작합니다...", threadID);

        Console.WriteLine("[{0} 스레드] 외부 변수 : {1}, {2}", threadID, x + y, outerParameter);

        Thread.Sleep(TimeSpan.FromSeconds(2));

        Console.WriteLine("[{0} 스레드] 람다 표현식 처리를 종료합니다...", threadID);
    }
);

using System;

using System.Threading;

...

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

/// <summary>

/// 테스트 처리하기

/// </summary>

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

private void Test(object parameter)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

Console.WriteLine("[{0} 스레드] 테스트 처리를 시작합니다...", threadID);

Console.WriteLine("[{0} 스레드] 매개 변수 : {1}", threadID, parameter ?? "(null)");

Thread.Sleep(TimeSpan.FromSeconds(2));

Console.WriteLine("[{0} 스레드] 테스트 종료를 시작합니다...", threadID);

}

#endregion

...

ThreadPool.QueueUserWorkItem(Test);

Thread.Sleep(TimeSpan.FromSeconds(1));

ThreadPool.QueueUserWorkItem(Test, "테스트 #2");

Thread.Sleep(TimeSpan.FromSeconds(1));

ThreadPool.QueueUserWorkItem

(

parameter =>

{

int threadID = Thread.CurrentThread.ManagedThreadId;

Console.WriteLine("[{0} 스레드] 람다 표현식 처리를 시작합니다...", threadID);

Console.WriteLine("[{0} 스레드] 매개 변수 : {1}", threadID, parameter);

Thread.Sleep(TimeSpan.FromSeconds(2));

Console.WriteLine("[{0} 스레드] 람다 표현식 처리를 종료합니다...", threadID);

"테스트 #3"

);

const int x = 1;

const int y = 2;

const string outerParameter = "테스트 #4";

ThreadPool.QueueUserWorkItem

(

_ =>

{

int threadID = Thread.CurrentThread.ManagedThreadId;

Console.WriteLine("[{0} 스레드] 람다 표현식 처리를 시작합니다...", threadID);

Console.WriteLine("[{0} 스레드] 외부 변수 : {1}, {2}", threadID, x + y, outerParameter);

Thread.Sleep(TimeSpan.FromSeconds(2));

Console.WriteLine("[{0} 스레드] 람다 표현식 처리를 종료합니다...", threadID);

}

);

[C#/COMMON] 대리자를 사용해 비동기 호출하기

■ 대리자를 사용해 비동기 호출하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading;

...

/// <summary>
/// 테스트 대리자
/// </summary>
/// <param name="threadID">스레드 ID</param>
private delegate void TestDelegate(out int threadID);

...

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

/// <summary>
/// 테스트 처리하기
/// </summary>
/// <param name="threadID">스레드 ID</param>
private void Test(out int threadID)
{
    threadID = Thread.CurrentThread.ManagedThreadId;

    Console.WriteLine("[{0} 스레드] 테스트 처리를 시작합니다...", threadID);

    Console.WriteLine("[{0} 스레드] 스레드풀 사용 여부 : {1}", threadID, Thread.CurrentThread.IsThreadPoolThread);

    Thread.Sleep(TimeSpan.FromSeconds(2));

    Console.WriteLine("[{0} 스레드] 테스트 처리를 종료 합니다...", threadID);
}

#endregion
#region 비동기 콜백 처리하기 - AsyncCallback(asyncResult)

/// <summary>
/// 비동기 콜백 처리하기
/// </summary>
/// <param name="asyncResult">비동기 결과</param>
private void AsyncCallback(IAsyncResult asyncResult)
{
    int threadID = Thread.CurrentThread.ManagedThreadId;

    Console.WriteLine("[{0} 스레드] 비동기 콜백 처리를 시작합니다...", threadID);

    Console.WriteLine("[{0} 스레드] 비동기 콜백 호출시 전달된 비동기 상태 : {1}", threadID, asyncResult.AsyncState);

    Console.WriteLine("[{0} 스레드] 스레드 풀 사용 여부 : {1}", threadID, Thread.CurrentThread.IsThreadPoolThread);
}

#endregion

...

TestDelegate testDelegate = Test;

IAsyncResult asyncResult = testDelegate.BeginInvoke(out threadID, AsyncCallback, "전달 값 #1");

asyncResult.AsyncWaitHandle.WaitOne();

testDelegate.EndInvoke(out threadID, asyncResult);

Console.WriteLine("다음 작업을 실행합니다.");

using System;

using System.Threading;

...

/// <summary>

/// 테스트 대리자

/// </summary>

/// <param name="threadID">스레드 ID</param>

private delegate void TestDelegate(out int threadID);

...

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

/// <summary>

/// 테스트 처리하기

/// </summary>

/// <param name="threadID">스레드 ID</param>

private void Test(out int threadID)

{

threadID = Thread.CurrentThread.ManagedThreadId;

Console.WriteLine("[{0} 스레드] 테스트 처리를 시작합니다...", threadID);

Console.WriteLine("[{0} 스레드] 스레드풀 사용 여부 : {1}", threadID, Thread.CurrentThread.IsThreadPoolThread);

Thread.Sleep(TimeSpan.FromSeconds(2));

Console.WriteLine("[{0} 스레드] 테스트 처리를 종료 합니다...", threadID);

}

#endregion

#region 비동기 콜백 처리하기 - AsyncCallback(asyncResult)

/// <summary>

/// 비동기 콜백 처리하기

/// </summary>

/// <param name="asyncResult">비동기 결과</param>

private void AsyncCallback(IAsyncResult asyncResult)

{

int threadID = Thread.CurrentThread.ManagedThreadId;

Console.WriteLine("[{0} 스레드] 비동기 콜백 처리를 시작합니다...", threadID);

Console.WriteLine("[{0} 스레드] 비동기 콜백 호출시 전달된 비동기 상태 : {1}", threadID, asyncResult.AsyncState);

Console.WriteLine("[{0} 스레드] 스레드 풀 사용 여부 : {1}", threadID, Thread.CurrentThread.IsThreadPoolThread);

}

#endregion

...

TestDelegate testDelegate = Test;

IAsyncResult asyncResult = testDelegate.BeginInvoke(out threadID, AsyncCallback, "전달 값 #1");

asyncResult.AsyncWaitHandle.WaitOne();

testDelegate.EndInvoke(out threadID, asyncResult);

Console.WriteLine("다음 작업을 실행합니다.");

[C#/COMMON] Thread 클래스 : 람다 표현식을 사용해 인자 전달하기

■ Thread 클래스에서 람다 표현식을 사용해 인자를 전달하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading;

#region 카운트 표시하기 - DisplayCount(loopCount)

/// <summary>
/// 카운트 표시하기
/// </summary>
/// <param name="loopCount">루프 카운트</param>
private static void DisplayCount(int loopCount)
{
    for(int i = 1; i <= loopCount; i++)
    {
        Thread.Sleep(TimeSpan.FromSeconds(0.5));

        Console.WriteLine("{0} : 카운트 {1}", Thread.CurrentThread.Name, i);
    }
}

#endregion

Thread thread = new Thread(() => DisplayCount(12));

thread.Name = "thread";

thread.Start();

using System;

using System.Threading;

#region 카운트 표시하기 - DisplayCount(loopCount)

/// <summary>

/// 카운트 표시하기

/// </summary>

/// <param name="loopCount">루프 카운트</param>

private static void DisplayCount(int loopCount)

{

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

{

Thread.Sleep(TimeSpan.FromSeconds(0.5));

Console.WriteLine("{0} : 카운트 {1}", Thread.CurrentThread.Name, i);

}

#endregion

Thread thread = new Thread(() => DisplayCount(12));

thread.Name = "thread";

thread.Start();

[C#/COMMON] Thread 클래스 : 스레드 메소드에 인자 전달하기

■ Thread 클래스에서 스레드 메소드에 인자를 전달하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Threading;

#region 카운트 표시하기 - DisplayCount(loopCount)

/// <summary>
/// 카운트 표시하기
/// </summary>
/// <param name="loopCount">루프 카운트</param>
private void DisplayCount(object loopCount)
{
    for(int i = 1; i <= (int)loopCount; i++)
    {
        Thread.Sleep(TimeSpan.FromSeconds(0.5));

        Console.WriteLine("{0} : 카운트 {1}", Thread.CurrentThread.Name, i);
    }
}

#endregion

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

thread.Name = "thread";

thread.Start(8);

using System;

using System.Threading;

#region 카운트 표시하기 - DisplayCount(loopCount)

/// <summary>

/// 카운트 표시하기

/// </summary>

/// <param name="loopCount">루프 카운트</param>

private void DisplayCount(object loopCount)

{

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

{

Thread.Sleep(TimeSpan.FromSeconds(0.5));

Console.WriteLine("{0} : 카운트 {1}", Thread.CurrentThread.Name, i);

}

#endregion

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

thread.Name = "thread";

thread.Start(8);

[C#/COMMON] Thread 클래스 : 클래스 객체를 사용해 인자 전달하기

■ Thread 클래스에서 클래스 객체를 사용해 인자를 전달하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Threading;

ThreadSample threadSample = new ThreadSample(10);

Thread thread = new Thread(new ThreadStart(threadSample.DisplayCount));

thread.Name = "thread";

thread.Start();

using System.Threading;

ThreadSample threadSample = new ThreadSample(10);

Thread thread = new Thread(new ThreadStart(threadSample.DisplayCount));

thread.Name = "thread";

thread.Start();

▶ ThreadSample.cs


using System;
using System.Threading;

/// <summary>
/// 스레드 샘플
/// </summary>
public class ThreadSample
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Field
    ////////////////////////////////////////////////////////////////////////////////////////// Private

    #region Field

    /// <summary>
    /// 루프 카운트
    /// </summary>
    private readonly int loopCount;

    #endregion

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

    #region 생성자 - ThreadSample(loopCount)

    /// <summary>
    /// 생성자
    /// </summary>
    /// <param name="loopCount">루프 카운트</param>
    public ThreadSample(int loopCount)
    {
        this.loopCount = loopCount;
    }

    #endregion

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

    #region 카운트 표시하기 - DisplayCount()

    /// <summary>
    /// 카운트 표시하기
    /// </summary>
    public void DisplayCount()
    {
        for(int i = 1; i <= loopCount; i++)
        {
            Thread.Sleep(TimeSpan.FromSeconds(0.5));

            Console.WriteLine("{0} : 카운트 {1}", Thread.CurrentThread.Name, i);
        }
    }

    #endregion
}

using System;

using System.Threading;

/// <summary>

/// 스레드 샘플

/// </summary>

public class ThreadSample

{

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

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

#region Field

/// <summary>

/// 루프 카운트

/// </summary>

private readonly int loopCount;

#endregion

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

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

#region 생성자 - ThreadSample(loopCount)

/// <summary>

/// 생성자

/// </summary>

/// <param name="loopCount">루프 카운트</param>

public ThreadSample(int loopCount)

{

this.loopCount = loopCount;

}

#endregion

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

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

#region 카운트 표시하기 - DisplayCount()

/// <summary>

/// 카운트 표시하기

/// </summary>

public void DisplayCount()

{

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

{

Thread.Sleep(TimeSpan.FromSeconds(0.5));

Console.WriteLine("{0} : 카운트 {1}", Thread.CurrentThread.Name, i);

}

#endregion

}

[C#/COMMON] Process 클래스 : ProcessorAffinity 속성을 사용해 현재 프로세스의 스레드 실행을 예약할 수 있는 프로세서 설정하기

■ Process 클래스의 ProcessorAffinity 속성을 사용해 현재 프로세스의 스레드 실행을 예약할 수 있는 프로세서를 설정하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Diagnostics;

Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(15); // 프로세서 1, 2, 3, 4를 사용한다.

using System.Diagnostics;

Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(15); // 프로세서 1, 2, 3, 4를 사용한다.

[C#/UWP] SuspendingDeferral 클래스 : 비동기 처리 대기하기

■ SuspendingDeferral 클래스를 사용해 비동기 처리를 대기하는 방법을 보여준다. ▶ 예제 코드 (C#)


using Windows.ApplicationModel;
using Windows.Storage;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;

...

private TextBox textBox;

...

Application.Current.Suspending += Application_Suspending;

...

private async void Application_Suspending(object sender, SuspendingEventArgs e)
{
    SuspendingDeferral suspendingDeferral = e.SuspendingOperation.GetDeferral();

    await PathIO.WriteTextAsync("ms-appdata:///local/sample.txt", this.textBox.Text);

    suspendingDeferral.Complete();
}

using Windows.ApplicationModel;

using Windows.Storage;

using Windows.UI.Xaml;

using Windows.UI.Xaml.Controls;

...

private TextBox textBox;

...

Application.Current.Suspending += Application_Suspending;

...

private async void Application_Suspending(object sender, SuspendingEventArgs e)

{

SuspendingDeferral suspendingDeferral = e.SuspendingOperation.GetDeferral();

await PathIO.WriteTextAsync("ms-appdata:///local/sample.txt", this.textBox.Text);

suspendingDeferral.Complete();

}

[C#/LINQ] ParallelEnumerable 클래스 : AsParallel 확장 메소드 사용하기

■ ParallelEnumerable 클래스의 AsParallel<TSource> 확장 메소드를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Collections.Generic;
using System.Linq;

/// <summary>
/// 학생
/// </summary>
public class Student
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Property
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 성명 - Name

    /// <summary>
    /// 성명
    /// </summary>
    public string Name { get; set; }

    #endregion

    #region 연령 - Age

    /// <summary>
    /// 연령
    /// </summary>
    public int Age { get; set; }

    #endregion
}

...

Random random = new Random();

List<Student> studentList = new List<Student>();

for(int i = 0; i < 1000000; i++)
{
    Student student = new Student();

    student.Name = string.Format("성명 {0}", i +1);
    student.Age  = random.Next(0, 100);

    studentList.Add(student);
}

var result = from    student in studentList.AsParallel()
             where   student.Age > 50
             orderby student.Age ascending
             select  student;

using System;

using System.Collections.Generic;

using System.Linq;

/// <summary>

/// 학생

/// </summary>

public class Student

{

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

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

#region 성명 - Name

/// <summary>

/// 성명

/// </summary>

public string Name { get; set; }

#endregion

#region 연령 - Age

/// <summary>

/// 연령

/// </summary>

public int Age { get; set; }

#endregion

}

...

Random random = new Random();

List<Student> studentList = new List<Student>();

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

{

Student student = new Student();

student.Name = string.Format("성명 {0}", i +1);

student.Age = random.Next(0, 100);

studentList.Add(student);

}

var result = from student in studentList.AsParallel()

where student.Age > 50

orderby student.Age ascending

select student;

※ AsParallel 메소드 추가만으로 PLINQ가 적용된다. ※ 단순

[C#/TPL] async … await 키워드 사용하기

■ async … await 키워드를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

private ListBox listBox;
private TextBox textBox;

...

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

/// <summary>
/// 버튼 클릭시 처리하기
/// </summary>
/// <param name="sender">이벤트 발생자</param>
/// <param name="e">이벤트 인자</param>
async private void button_Click(object sender, EventArgs e)
{
    await AddItemAsync(this.textBox.Text, 10);
}

#endregion

#region 항목 비동기 추가하기 - AddItemAsync(message, count)

/// <summary>
/// 항목 비동기 추가하기
/// </summary>
/// <param name="message">메시지</param>
/// <param name="count">카운트</param>
/// <returns>태스크</returns>
private Task AddItemAsync(string message, int count)
{
    return Task.Run(() =>
    {
        for(int i = 0; i < count; i++)
        {
            this.listBox.Items.Add(message + ", " + i.ToString());

            Thread.Sleep(500);
        }
    });
}

#endregion

using System;

using System.Threading;

using System.Threading.Tasks;

using System.Windows.Forms;

...

private ListBox listBox;

private TextBox textBox;

...

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

/// <summary>

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

/// </summary>

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

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

async private void button_Click(object sender, EventArgs e)

{

await AddItemAsync(this.textBox.Text, 10);

}

#endregion

#region 항목 비동기 추가하기 - AddItemAsync(message, count)

/// <summary>

/// 항목 비동기 추가하기

/// </summary>

/// <param name="message">메시지</param>

/// <param name="count">카운트</param>

/// <returns>태스크</returns>

private Task AddItemAsync(string message, int count)

{

return Task.Run(() =>

{

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

{

this.listBox.Items.Add(message + ", " + i.ToString());

Thread.Sleep(500);

}

});

}

#endregion

[C#/TPL] async … await 키워드 사용하기

■ async … await 키워드를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

private ListBox listBox;
private TextBox textBox;

...

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

/// <summary>
/// 버튼 클릭시 처리하기
/// </summary>
/// <param name="sender">이벤트 발생자</param>
/// <param name="e">이벤트 인자</param>
async private void button_Click(object sender, EventArgs e)
{
    await AddItemAsync(this.textBox.Text, 10);
}

#endregion

#region 항목 비동기 추가하기 - AddItemAsync(message, count)

/// <summary>
/// 항목 비동기 추가하기
/// </summary>
/// <param name="message">메시지</param>
/// <param name="count">카운트</param>
/// <returns>태스크</returns>
private Task AddItemAsync(string message, int count)
{
    Action action = delegate()
    {
        for(int i = 0; i < count; i++)
        {
            this.listBox.Items.Add(message +", " + i.ToString());

            Thread.Sleep(500);
        }
    };

    Task task = new Task(action);

    task.Start();

    return task;
}

#endregion

using System;

using System.Threading;

using System.Threading.Tasks;

using System.Windows.Forms;

...

private ListBox listBox;

private TextBox textBox;

...

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

/// <summary>

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

/// </summary>

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

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

async private void button_Click(object sender, EventArgs e)

{

await AddItemAsync(this.textBox.Text, 10);

}

#endregion

#region 항목 비동기 추가하기 - AddItemAsync(message, count)

/// <summary>

/// 항목 비동기 추가하기

/// </summary>

/// <param name="message">메시지</param>

/// <param name="count">카운트</param>

/// <returns>태스크</returns>

private Task AddItemAsync(string message, int count)

{

Action action = delegate()

{

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

{

this.listBox.Items.Add(message +", " + i.ToString());

Thread.Sleep(500);

}

};

Task task = new Task(action);

task.Start();

return task;

}

#endregion

[C#/TPL] async … await 키워드 사용하기

■ async … await 키워드를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

...

private ListBox listBox;
private TextBox textBox;

...

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

/// <summary>
/// 버튼 클릭시 처리하기
/// </summary>
/// <param name="sender">이벤트 발생자</param>
/// <param name="e">이벤트 인자</param>
async private void button_Click(object sender, EventArgs e)
{
    await Task.Run(() =>
    {
            for(int i = 0; i < 10; i++)
            {
                this.listBox.Items.Add(this.textBox.Text + ", " + i.ToString());

                Thread.Sleep(500);
            }
    });
}

#endregion

using System;

using System.Threading;

using System.Threading.Tasks;

using System.Windows.Forms;

...

private ListBox listBox;

private TextBox textBox;

...

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

/// <summary>

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

/// </summary>

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

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

async private void button_Click(object sender, EventArgs e)

{

await Task.Run(() =>

{

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

{

this.listBox.Items.Add(this.textBox.Text + ", " + i.ToString());

Thread.Sleep(500);

}

});

}

#endregion

[C#/COMMON] Process 클래스 : 엑셀 프로세스 ID 구하기

■ Process 클래스를 사용해 엑셀 프로세스 ID를 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Collections.Generic;
using System.Diagnostics;

Process[] excelProcessArray = Process.GetProcessesByName("EXCEL");

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

for(int i = 0; i < excelProcessArray.Length; i++)
{
    excelProcessIDList.Add(excelProcessArray[i].Id);
}

using System.Collections.Generic;

using System.Diagnostics;

Process[] excelProcessArray = Process.GetProcessesByName("EXCEL");

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

for(int i = 0; i < excelProcessArray.Length; i++)

{

excelProcessIDList.Add(excelProcessArray[i].Id);

}

[C#/COMMON] Process 클래스 : 윈도우즈 잠금 화면(Lock Screen) 표시하기

■ Process 클래스를 사용해 윈도우즈 잠금 화면(Lock Screen)을 표시하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Diagnostics;

Process process = new Process( );

process.StartInfo.FileName         = "rundll32.exe";
process.StartInfo.WorkingDirectory = @"C:\Windows\System32\";
process.StartInfo.WindowStyle      = ProcessWindowStyle.Hidden;
process.StartInfo.Arguments        = "user32.dll, LockWorkStation";
process.Start();

using System.Diagnostics;

Process process = new Process( );

process.StartInfo.FileName = "rundll32.exe";

process.StartInfo.WorkingDirectory = @"C:\Windows\System32\";

process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;

process.StartInfo.Arguments = "user32.dll, LockWorkStation";

process.Start();

[VB] 프로세스 제거하기

■ 프로세스를 제거하는 방법을 보여준다. ▶ 예제 코드 (VB)


Private Function KillProcess(strProcess As String)

    Dim pService   As Object
    Dim pObjectSet As Object
    Dim pObject    As Object

    Set pService = GetObject("winmgmts:")

    Set pObjectSet = pService.ExecQuery("SELECT * FROM win32_process")

    For Each pObject In pObjectSet

        DoEvents

        If LCase(pObject.Name) = strProcess Then

            pObject.Terminate

            Exit For

        End If

    Next

End Function

Private Function KillProcess(strProcess As String)

Dim pService As Object

Dim pObjectSet As Object

Dim pObject As Object

Set pService = GetObject("winmgmts:")

Set pObjectSet = pService.ExecQuery("SELECT * FROM win32_process")

For Each pObject In pObjectSet

DoEvents

If LCase(pObject.Name) = strProcess Then

pObject.Terminate

Exit For

End If

End Function

[C#/WPF] 크로스 스레드(Cross Thread) 처리하기

■ 크로스 스레드(Cross Thread)를 처리하는 방법을 보여준다. ▶ 예제 코드 (C#)


/// <summary>
/// 버튼 갱신하기 대리자
/// </summary>
/// <param name="button">버튼</param>
/// <param name="content">컨텐트</param>
private delegate void UpdateButtonDelegate(Button button, object content);

#region 버튼 갱신하기 - UpdateButton(button, content)

/// <summary>
/// 버튼 갱신하기
/// </summary>
/// <param name="button">버튼</param>
/// <param name="content">컨텐트</param>
private void UpdateButton(Button button, object content)
{
    if(button.CheckAccess())
    {
        button.Content = content;
    }
    else
    {
        UpdateButtonDelegate updateButtonDelegate = new UpdateButtonDelegate(UpdateButton);

        button.Dispatcher.BeginInvoke(updateButtonDelegate, button, content);
    }
}

#endregion

/// <summary>

/// 버튼 갱신하기 대리자

/// </summary>

/// <param name="button">버튼</param>

/// <param name="content">컨텐트</param>

private delegate void UpdateButtonDelegate(Button button, object content);

#region 버튼 갱신하기 - UpdateButton(button, content)

/// <summary>

/// 버튼 갱신하기

/// </summary>

/// <param name="button">버튼</param>

/// <param name="content">컨텐트</param>

private void UpdateButton(Button button, object content)

{

if(button.CheckAccess())

{

button.Content = content;

}

else

{

UpdateButtonDelegate updateButtonDelegate = new UpdateButtonDelegate(UpdateButton);

button.Dispatcher.BeginInvoke(updateButtonDelegate, button, content);

}

#endregion

[C#/COMMON] Process 클래스 : 파일 프로세스 실행하기

■ Process 클래스를 사용해 파일 프로세스를 실행하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Diagnostics;

#region 파일 프로세스 실행하기 - ExecuteFileProcess(fullPath)

/// <summary>
/// 파일 프로세스 실행하기
/// </summary>
/// <param name="fullPath">완전한 경로</param>
public void ExecuteFileProcess(string fullPath)
{
    Process process = new Process();

    process.StartInfo.FileName    = fullPath;
    process.StartInfo.Verb        = "Open";
    process.StartInfo.WindowStyle = ProcessWindowStyle.Normal;

    process.Start();
}

#endregion

using System.Diagnostics;

#region 파일 프로세스 실행하기 - ExecuteFileProcess(fullPath)

/// <summary>

/// 파일 프로세스 실행하기

/// </summary>

/// <param name="fullPath">완전한 경로</param>

public void ExecuteFileProcess(string fullPath)

{

Process process = new Process();

process.StartInfo.FileName = fullPath;

process.StartInfo.Verb = "Open";

process.StartInfo.WindowStyle = ProcessWindowStyle.Normal;

process.Start();

}

#endregion

[C#/COMMON] 실행 프로세스 여부 조사하기

■ 실행 프로세스 여부를 조사하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Diagnostics;
using System.Threading;

#region 실행 프로세스 여부 조사하기 - CheckRunningProcess(processName)

/// <summary>
/// 실행 프로세스 여부 조사하기
/// </summary>
/// <param name="processName">프로세스명</param>
/// <returns>실행 프로세스 여부 조사 결과</returns>
public bool CheckRunningProcess(string processName)
{
    for(int i = 0; ; i++)
    {
        Thread.Sleep(500);

        Process[] processArray = Process.GetProcessesByName(processName);

        // 10초 동안 반복한다.
        if(i <= 20)
        {
            if(processArray.Length == 0)
            {
                continue;
            }
            else
            {
                return true;
            }
        }
        else
        {
            return false;
        }
    }
}

#endregion

using System.Diagnostics;

using System.Threading;

#region 실행 프로세스 여부 조사하기 - CheckRunningProcess(processName)

/// <summary>

/// 실행 프로세스 여부 조사하기

/// </summary>

/// <param name="processName">프로세스명</param>

/// <returns>실행 프로세스 여부 조사 결과</returns>

public bool CheckRunningProcess(string processName)

{

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

{

Thread.Sleep(500);

Process[] processArray = Process.GetProcessesByName(processName);

// 10초 동안 반복한다.

if(i <= 20)

{

if(processArray.Length == 0)

{

continue;

}

else

{

return true;

}

else

{

return false;

}

#endregion

[C#/COMMON] Process 클래스 : Kill 메소드를 사용해 프로세스 제거하기

■ Process 클래스의 Kill 메소드를 사용해 프로세스를 제거하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Diagnostics;

#region 프로세스 죽이기 - KillProcess(processArray)

/// <summary>
/// 프로세스 죽이기
/// </summary>
/// <param name="processArray">프로세스 배열</param>
public void KillProcess(Process[] processArray)
{
    foreach(Process process in processArray)
    {
        process.Kill();
    }
}

#endregion

using System.Diagnostics;

#region 프로세스 죽이기 - KillProcess(processArray)

/// <summary>

/// 프로세스 죽이기

/// </summary>

/// <param name="processArray">프로세스 배열</param>

public void KillProcess(Process[] processArray)

{

foreach(Process process in processArray)

{

process.Kill();

}

#endregion

[C#/COMMON] Process 클래스 : 시작 명칭으로 프로세스 배열 구하기

■ Process 클래스에서 시작 명칭으로 프로세스 배열을 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Collections.Generic;
using System.Diagnostics;

#region 시작 명칭으로 프로세스 배열 구하기 - GetProcessesByStartName(processName)

/// <summary>
/// 시작 명칭으로 프로세스 배열 구하기
/// </summary>
/// <param name="processName">프로세스명</param>
/// <returns>프로세스 배열</returns>
public Process[] GetProcessesByStartName(string processName)
{
    Process[]     allProcessArray = Process.GetProcesses();
    List<Process> processList     = new List<Process>();

    foreach(Process process in allProcessArray)
    {
        if(process.ProcessName.StartsWith(processName))
        {
            processList.Add(process);
        }
    }

    return processList.ToArray();
}

#endregion

using System.Collections.Generic;

using System.Diagnostics;

#region 시작 명칭으로 프로세스 배열 구하기 - GetProcessesByStartName(processName)

/// <summary>

/// 시작 명칭으로 프로세스 배열 구하기

/// </summary>

/// <param name="processName">프로세스명</param>

/// <returns>프로세스 배열</returns>

public Process[] GetProcessesByStartName(string processName)

{

Process[] allProcessArray = Process.GetProcesses();

List<Process> processList = new List<Process>();

foreach(Process process in allProcessArray)

{

if(process.ProcessName.StartsWith(processName))

{

processList.Add(process);

}

return processList.ToArray();

}

#endregion

[DATABASE/SQLSERVER] 프로세스 CPU 점유율 조회하기

■ 프로세스의 CPU 점유율을 조회하는 방법을 보여준다. ▶ 예제 코드 (SQL)


SELECT TOP 10 * FROM master.dbo.sysprocesses AS A ORDER BY A.cpu DESC;

SELECT TOP 10 * FROM master.dbo.sysprocesses AS A ORDER BY A.cpu DESC;

[C#/COMMON] Process 클래스 : 윈도우즈 종료/재부팅 취소하기

■ Process 클래스를 사용해 윈도우즈 종료/재부팅을 취소하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Diagnostics;

Process.Start("shutdown.exe", "/a");

using System.Diagnostics;

Process.Start("shutdown.exe", "/a");

[C#/COMMON] Process 클래스 : 윈도우즈 재부팅하기

■ Process 클래스를 사용해 윈도우즈를 재부팅하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Diagnostics;

Process.Start("shutdown.exe", "/r /f /t 00");

using System.Diagnostics;

Process.Start("shutdown.exe", "/r /f /t 00");

※ '/t 10' 설정시 10초 후 실행을 의미한다.

[C#/COMMON] Process 클래스 : Start 정적 메소드를 사용해 명령 프롬프트 실행하기

■ Process 클래스의 Start 정적 메소드를 사용해 명령 프롬프트를 실행하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Diagnostics;

Process.Start("cmd.exe", "/c ping 127.1.1.1");

using System.Diagnostics;

Process.Start("cmd.exe", "/c ping 127.1.1.1");