[cpp/winrt] win32프로젝트(MFC, WTL..)에서 DispatcherQueue사용하기 (코루틴)

0. 불편하다 PostThreadMessage

윈도우는 생성된 스레드에서 UI 작업(창을 만든다거나) 하거나 GetMessage 로 메시지 루프를 만들면 메시지 큐를 생성한다.

https://learn.microsoft.com/en-us/windows/win32/winmsg/using-messages-and-message-queues

Using Messages and Message Queues - Win32 apps

이렇게 생성된 메시지 큐는 메시지 Dispatch를 하여 처리할 수 있게 된다. Windows 창의 메시지 프로시저가 그것을 처리한다. 이렇게 생성된 쓰레드는 UI쓰레드라고 불리며 보통 UI작업을 하게된다. 

그리고 이렇게 UI쓰레드는 메인쓰레드 이외에 또 만들 수 있다. MFC에서는 CWinThread을 활용하여 메시지 큐를 가진 쓰레드를 생성하고 PostThreadMessage로 메시지를 처리 한다. 이것은 마치 iOS의 GCD의 Dispatch Queue를 연상케 한다.

iOS를 개발하면서 Dispatch Queue는 쓰레드를 매우쉽게 생성하고 쉽게 사용할 수 있게 도와주었다.

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 1. 자동 캡처되는 로컬 변수
        NSString *message = @"Hello from captured variable!";
        
        // 2. 직렬 큐 생성
        dispatch_queue_t serialQueue = dispatch_queue_create("com.example.serialQueue", DISPATCH_QUEUE_SERIAL);
        
        // 3. 블록에서 로컬 변수 캡처
        dispatch_async(serialQueue, ^{
            // 캡처된 로컬 변수 사용
            NSLog(@"🔷 캡처된 변수 메시지: %@", message);
        });
        
        // 메인 스레드가 종료되지 않도록 대기
        [[NSRunLoop currentRunLoop] run];
    }
    return 0;
}

윈도우에서도 메시지 큐를 가진 쓰레드를 생성하여 비슷하게 사용할 수 있었지만 iOS의 Dispatch Queue만큼 편리하진 않았다. 일일히 윈도우 메시지를 Difine해놔야 했으며 파라미터는 LPARAM, WPARAM으로 포인터만 전달 할 수 있었고, 때문에 동적 할당된 메모리가 불안하게 PostThreadMessage로 전달되었다. 그리고 이렇게 받은 메모리는 메시지 콜백에서 반드시 삭제해줘야 했으니.. 불편하기 짝이없다.

대충 이런식이다.(GPT가 짜준거니 진짜 돌려보진 말자.)

#include <windows.h>
#include <iostream>

#define WM_CUSTOM_MESSAGE (WM_USER + 1)

// 동적 할당할 데이터 구조체
struct CustomData {
    int value;
    char message[50];
};

// 메시지를 처리하는 스레드
DWORD WINAPI MessageThreadProc(LPVOID lpParam) {
    MSG msg;

    while (GetMessage(&msg, nullptr, 0, 0)) {
        switch (msg.message) {
            case WM_CUSTOM_MESSAGE: {
                CustomData* data = reinterpret_cast<CustomData*>(msg.lParam);
                if (data) {
                    std::cout << "Received WM_CUSTOM_MESSAGE: value=" 
                              << data->value << ", message=" << data->message << std::endl;
                    delete data; // 동적 메모리 해제
                }
                break;
            }
            case WM_QUIT:
                std::cout << "Received WM_QUIT. Exiting thread." << std::endl;
                return 0;
            default:
                TranslateMessage(&msg);
                DispatchMessage(&msg);
                break;
        }
    }

    return 0;
}

int main() {
    DWORD threadId;
    HANDLE hThread = CreateThread(nullptr, 0, MessageThreadProc, nullptr, 0, &threadId);
    if (!hThread) {
        std::cerr << "Failed to create thread." << std::endl;
        return 1;
    }

    // 메시지 큐가 생성될 시간을 확보
    Sleep(100);

    // 동적 할당하여 데이터 생성
    CustomData* data = new CustomData{42, "Hello from main thread!"};

    // 메시지 전송 (LPARAM에 동적 할당된 포인터 전달)
    PostThreadMessage(threadId, WM_CUSTOM_MESSAGE, 0, reinterpret_cast<LPARAM>(data));

    // 종료 메시지 전송
    Sleep(500);
    PostThreadMessage(threadId, WM_QUIT, 0, 0);

    // 스레드 종료 대기 및 정리
    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);

    return 0;
}

요즘시대에  LPARAM, WPARAM PostThreadMessage를 던지고 앉아있자니 속이 터진다.

 

1. winrt::Windows::System::DispatcherQueue 가 있다.

그러던 중 뭐 없을까 찾아보니 winrt에 DispatcherQueue가 있더라. 자세한 설명은 아래 MSDN을 참고하자.

https://learn.microsoft.com/ko-kr/windows/apps/develop/dispatcherqueue 

DispatcherQueue - Windows apps

1.1. 간단한 사용방법

1.1.1. 새로운 쓰레드를 생성하여 Dispatcher Queue 만들고 사용하기

매우 간단하다. 

#include <winrt/base.h>
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.System.h>
#include <DispatcherQueue.h>

winrt::Windows::System::DispatcherQueueController controller 
= winrt::Windows::System::DispatcherQueueController::CreateOnDedicatedThread(); 
//새로운 스레드 디스패처큐 컨트롤러 생성


winrt::Windows::System::DispatcherQueue dispatcher 
= controller.DispatcherQueue(); //디스패처큐 얻기

winrt::hstring str {L"hello"};

dispatcher.TryEnqueue([str]() { // 큐에 넣기 실행
	OutputDebugString(str);
	});

controller.ShutdownQueueAsync().get(); //종료

작업 큐에 변수 전달도 람다 캡처로 전달되어 매우 편하다. LPARAM, WPARAM 쑈를 안해도된다. 코드도 너무 직관적으로 바뀐다.

1.1.2. 현재 쓰레드에 Dispatcher Queue 연결하기

기본적으로 mfc나 WTL등 gui가 있는 Windows프로젝트는 메인 스레드의 메시지루프가 돌고 있다. 이것으로 UI이벤트 메시지를 처리한다. Winrt의 DispatcherQueue는 이 메인스레드 루프에 연동되어 돌아갈 수도 있다. 즉 메인 메시지 루프의 프로시저를 정의하지 않고도 어디서든 메인스레드를 호출하여 사용할 수 있다는 것.

Win32에서도 호출 가능하도록 dispatcherqueue 헤더를 지원하고 있다.

https://learn.microsoft.com/ko-kr/windows/win32/api/dispatcherqueue/

Dispatcherqueue.h 헤더 - Win32 apps

 

사용 방법은 이렇다.

#include <winrt/base.h>
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.System.h>
#include <DispatcherQueue.h>


using namespace winrt;
using namespace winrt::Windows::System;


// 현재쓰레드의 디스패처 큐 컨트롤러를 만든다.
DispatcherQueueController CreateDispatcherQueueController()
{
	DispatcherQueueOptions options{
		sizeof(DispatcherQueueOptions),
		DQTYPE_THREAD_CURRENT,
		DQTAT_COM_NONE
	};

	DispatcherQueueController controller{ nullptr };
	HRESULT hr = CreateDispatcherQueueController(options, reinterpret_cast<ABI::Windows::System::IDispatcherQueueController**>(winrt::put_abi(controller)));

	if (FAILED(hr))
	{
		throw winrt::hresult_error(hr);
	}

	return controller;
}

//........


winrt::Windows::System::DispatcherQueueController mainDispatcherController = nullptr;
winrt::Windows::System::DispatcherQueue mainDispatcher = nullptr;

mainDispatcherController = CreateDispatcherQueueController();
mainDispatcher = controller.DispatcherQueue();

//.......
//win32 메시지루프..


MSG msg;
while (GetMessage(&msg, nullptr, 0, 0))
{
    if (!ContentPreTranslateMessage(&msg))
    {
        TranslateMesasge(&msg);
        DispatchMessage(&msg);
    }
}

// 메인스레드 큐로 작업실행

dispatcher.TryEnqueue([]() {
    OutputDebugString(L"hello world!!!");
    });

 

2. 사용해 보기

2.1. Win32 프로젝트에서 사용해보기 (WTL)

나는 기존 레거시덩어리인 MFC, WTL, Win32 프로젝트에서 써먹는 방법이 궁금하다. 그리고 써먹을 수 있을지도 궁금하다.

일단나는 WTL프로젝트에서 테스트해보기로 했다. MFC나 win32프로젝트도 마찬가지 일 것이다.

테스트 시나리오는 다음과 같다.

1. 메인스레드에서 DispatcherQueue를 생성하여 기본 메시지루프와 같이 돌게 한다.
2.  또다른 쓰레드를 사용하는 DispatcherQueue를 생성한다.
3. 코루틴으로 하나의 함수에서 두개의 쓰레드로 작업해본다.

2.1.2. DispatcherQueue 만들기

메인함수에서 main thread dispatcher queue와 background dispatcher queue를 생성한다. 

winrt::Windows::System::DispatcherQueueController controller = nullptr;
winrt::Windows::System::DispatcherQueue dispatcher = nullptr;

winrt::Windows::System::DispatcherQueueController backgroundController = nullptr;
winrt::Windows::System::DispatcherQueue backgroundDispatcher = nullptr;

int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR /*lpstrCmdLine*/, int /*nCmdShow*/)
{
	
	winrt::init_apartment();
	controller = CreateDispatcherQueueController();
	dispatcher = controller.DispatcherQueue();
	
	backgroundController = winrt::Windows::System::DispatcherQueueController::CreateOnDedicatedThread();
	backgroundDispatcher = backgroundController.DispatcherQueue();

	dispatcher.TryEnqueue([]() {
		OutputDebugString(L"hello world!!!");
		});

	AtlInitCommonControls(ICC_BAR_CLASSES);	// add flags to support other controls

	HRESULT hRes = _Module.Init(NULL, hInstance);
	ATLASSERT(SUCCEEDED(hRes));

	int nRet = 0;
	// BLOCK: Run application
	{
		CMainDlg dlgMain;
		nRet = (int)dlgMain.DoModal();
	}

	_Module.Term();
	
	backgroundController.ShutdownQueueAsync().get();

	return nRet;
}

편의상 전역변수로 선언해 놓았는데 프로젝트 전역에서 참조하기 위해 다른 헤더에는 extern으로 선언해 놓았다.

// stdafx.h

extern winrt::Windows::System::DispatcherQueueController controller;
extern winrt::Windows::System::DispatcherQueue dispatcher;

extern winrt::Windows::System::DispatcherQueueController backgroundController;
extern winrt::Windows::System::DispatcherQueue backgroundDispatcher;

2.1.2. 버튼을 만들고 버튼 처리 추가

rc에서 다이얼로그에 흔한 버튼1을 생성하고 메시지 핸들러를 아래와 같이 등록해 두었다.

LRESULT CMainDlg::OnBnClickedButton1(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
    // main thread

    {
        CString str;
        str.Format(_T(" queue tid=%lu\n"), ::GetCurrentThreadId());
        OutputDebugString(str);
    }
    
    
	// background thread
    backgroundDispatcher.TryEnqueue([]() {
        CString str;
        str.Format(_T(" queue tid=%lu\n"), ::GetCurrentThreadId());
        OutputDebugString(str);

        });

    


    return 0;
}

첫번째 output출력은 메인스레드에서 될 것이고, 두번째는 background 스레드에서 동작할 것이다. 구분을 하기위해 thread id를 출력하도록 하였다. 

결과는 다르게 출력된다. 

메인스레드와 background 스레드에서 동작함을 볼 수 있다.

 

2.3.1. 코루틴 적용해보기

코루틴은 서로 다른 스레드를 넘나들며 작업할 수 있게 해주는 유용한 기능이다. 함수를 여러개 만들지 않고도 하나의 함수안에서 이리저리 처리를 할 수 있다.

https://learn.microsoft.com/ko-kr/windows/uwp/cpp-and-winrt-apis/concurrency-2

C++/WinRT를 통한 고급 동시성 및 비동기 - UWP applications

 

IAsyncAction MainPage::ClickHandler(IInspectable /* sender */, RoutedEventArgs /* args */)
{
    // We begin in the UI context.

    co_await winrt::resume_background();

    // We're now on a background thread.

    // Call StorageFile::OpenAsync to load an image file.

    // Process the image.

    co_await winrt::resume_foreground(this->Dispatcher());

    // We're back on MainPage's UI thread.

    // Display the image in the UI.
}

요런 고급진걸 구닥다리 Win32에서 적용할 수 있을까?

2.3.2. 비동기 함수 작성(IAsyncAction)

코루틴과 같은 작업을 하기 위해서는 비동기 함수를 작성해 줘야한다. 조금 특수하다.

winrt::Windows::Foundation::IAsyncAction DoBackgroundWork()
{
    for (int i = 0; i < 10; i++)
    {
        co_await winrt::resume_foreground(backgroundDispatcher);
        {
            CString str;
            str.Format(_T("Background queue tid=%lu\n"), ::GetCurrentThreadId());
            OutputDebugString(str);
        }
        co_await winrt::resume_foreground(dispatcher);
        {
            CString str;
            str.Format(_T("main queue tid=%lu\n"), ::GetCurrentThreadId());
            OutputDebugString(str);
        }
        Sleep(1000);
    }

    co_return;
}

내가 만든 함수는 1초에 한번씩 10번 background 스레드에서 output을 출력, 메인스레드에서 output출력하는 것이다.

아까 만든 버튼1의 메시지 핸들러에서 비동기 함수 DoBackgroundWork()를 호출해준다.

LRESULT CMainDlg::OnBnClickedButton1(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
    auto op{ DoBackgroundWork() };
    return 0;
}

비동기 호출로 이루어지므로 버튼1클릭시 blocking은 없다.

결과는?

 

서로 다른 스레드에서 동작함을 확인 할 수 있다. 

 

3. 결론

• 구닥다리 win32 프로젝트에서도 최신 기술을 winrt를 통해 구현해 낼 수 있다.
• DispatcherQueue를 이용해서 PostThreadMessage같은거에서 해방될 수 있다.

 

 

MyWTLWinrt-coroutine.zip

0.02MB