PeekMessage inside thread - c++

Question

I'm a bit confused. What I'm trying to do - is to create a window messages loop inside a different thread. My code looks like this:
//...
#include <thread>
//...
void MyClass::runMainLoop() {
new thread(mainLoop, this); //I know this will cause a memory leak - just for testing
}
void MyClass::mainLoop(MyClass* _this) { // <- static method
cout << "start thread" << endl; //loop function started
MSG msg;
while (true) {
while (PeekMessage(&msg, _this->_hWnd, 0, 0, PM_REMOVE)) {
cout << msg.message << " "; //we've got a message! (don't get here inside a thread)
if (msg.message == WM_QUIT) {
cout << "exiting" << endl; //closing window
break;
}
DispatchMessage(&msg);
}
Sleep(2);
}
}
The message "start thread" appears, but I don't see that any messages where handled. On the other hand, when I call to mainLoop() method without creating a thread, everything seems to work fine:
void MyClass::runMainLoop() {
mainLoop(this);
}
I tryed to dig into MSDN, but didn't find anything on my problem. It seems, that I have some gaps in my knowledge, which can't be filled in a reasonable time.
My thought was that the thread somehow "don't know" about a window I've created inside my main program thread.
So, the question is - what am I doing wrong? Why the message loop isn't working in thread?
EDIT:
The code which creates the window. It runs in the program's main thread.
WNDCLASSEX wcx;
PIXELFORMATDESCRIPTOR pfd;
RECT rect;
HGLRC hRCTemp;
DWORD style, exStyle;
int x, y, format;
_hInstance = (HINSTANCE)GetModuleHandle(NULL);
//Register window class
memset(&wcx, 0, sizeof(wcx));
wcx.cbSize = sizeof(wcx);
wcx.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wcx.lpfnWndProc = (WNDPROC)windowProc;
wcx.hInstance = _hInstance;
wcx.lpszClassName = L"windowClassName";
wcx.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wcx.hCursor = LoadCursor(NULL, IDC_ARROW);
RegisterClassEx(&wcx)
//Window styles
style = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
exStyle = WS_EX_APPWINDOW;
//place window at the cetner of the screen
x = (GetSystemMetrics(SM_CXSCREEN) - width) / 2;
y = (GetSystemMetrics(SM_CYSCREEN) - height) / 2;
rect.left = x;
rect.right = x + width;
rect.top = y;
rect.bottom = y + height;
//Adjust window size to styles
AdjustWindowRectEx(&rect, style, FALSE, exStyle);
//Create a window
_hWnd = CreateWindowEx(exStyle, wcx.lpszClassName, L"Window caption", style, rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top, NULL, NULL, _hInstance, NULL);
EDIT 2:
Thanks to all those who commented my question, I understand now where the problem is: the thread that created the window receives the messages for it.
So, I'll rephrase the question: can I redirect window messages to another thread? I tried AttachThreadInput, but didn't succeed.

Answer 1

An HWND is tied to the thread context that it is created in. Only the thread context that creates an HWND can receive messages for that HWND. When you call mainLoop() directly in runMainLoop(), mainLoop() is running in the same thread context that created the HWND, which is why it works. Once you move mainLoop() to a different thread, it can no longer receive messages for the HWND.
An HWND's message pump must be in the same thread that created the HWND. There is no getting around that limitation. So if you want to service the HWND in a different thread then you have to create the HWND in that thread.

Answer 2

The best thing to do would be a producer/consumer model.
When you create your window, add a handler that will add to a queue:
// Global scope...
std::queue<MSG*> g_messages;
std::mutex g_mutex;
std::condition_variable g_cond;
Then your main loop would look like (for the thread that created the window):
void MyClass::mainLoop(MyClass* _this) { // <- static method
while (true) {
MSG *msg = new MSG;
while (PeekMessage(msg, _this->_hWnd, 0, 0, PM_REMOVE)) {
std::unique_lock<std::mutex> lock(g_mutex);
g_messages.push(msg);
g_cond.notify_all();
}
DispatchMessage(msg);
}
}
And create your threads like this:
std::thread t([]() {
MSG *msg;
while (true) {
// Wait for a message
{
std::unique_lock<std::mutex> lock(g_mutex);
while (g_messages.empty()) g_cond.wait(lock);
msg = g_messages.front();
g_messages.pop();
}
// Got a message, process it
if (msg->message == WM_QUIT) {
cout << "exiting" << endl; //closing window
break;
}
}
});

Answer 3

response to your EDIT 2
You can redirect the messages of the window to another thread by creating the window in the thread. The thread must not only handle the messages, but also the creation via an event-driven model and MsgWaitForMultipleObjects. Or via a private message you send from main thread to the created thread via PostThreadMessage.
The latter model:
from main thread:
create the thread
call PostThreadMessage(tid, MYPRIVATEMESSAGE, wparam, lparam)
in the thread created:
loop GetMessage()
{
if (message == MYPRIVATEMESSAGE)
{
create the window, use wParam/lParam to pass optional parameters
}
else
{
translate message
dispatch message
}
}