WinApi message loop, Postmessage works like SendMessage
c++, getmessage, postmessage, winapi
Solution
Some notes about this code:
- You should NOT create threads in `WM_PAINT`. Nor should you call `MessageBox` in `WM_PAINT`. `WM_PAINT` is only for painting your window; no other logic should be executed here. The system optimizes `WM_PAINT` calls and behavior can get really tricky when you start overstaying your welcome in this handler.
- You should also never cast a function call like you do with `(LPTHREAD_START_ROUTINE)&thread`. If your function is not the right type, change the function prototype; don't just try and hide the compiler's warnings.
- You should probably use `_beginthread`, because the CRT has some initialization to perform.
- You should pass `hWnd` as the thread parameter, not `&hWnd`. The pointer can go out of scope and become invalid. This is a critical bug.
To really see what's going on, you should fix these errors first.
To answer your question, the different threads have no guarantee of speed. After you split off a thread, there is now no telling what will happen next. They are asynchronous. Maybe the thread code runs faster than your main thread, maybe vice-versa.
Keep in mind that `MessageBox` has its own internal message loop. So the callstack at `WM_USER+11` (MessageBox4) is going to look something like this:
MessageBox (4)
WndProc (WM_USER+11)
DispatchMessage
MessageBox (3), before it's actually shown
WndProc (WM_PAINT)
DispatchMessage
WinMain
So you can see that if the thread posts the message quickly enough, it will be processed before `MessageBox(3)` will be shown.
My guess is if you use a lighter debugging technique (`OutputDebugString` for example), you'll observe more predictable behavior.
Problem
Hello can Somebody answer me why when I run this program the order of MessageBoxes is 1,2,4,3 instead of 1,2,3,4. In my opinion program should end executing WM_PAINT procedure before start WM_USER+11, why it isn't? ``` // Win32Project6.cpp : Defines the entry point for the application. // #include "stdafx.h" #include "Win32Project6.h" #define MAX_LOADSTRING 100 // Global Variables: HINSTANCE hInst; // current instance TCHAR szTitle[MAX_LOADSTRING]; // The title bar text TCHAR szWindowClass[MAX_LOADSTRING]; // the main window class name // Forward declarations of functions included in this code module: ATOM MyRegisterClass(HINSTANCE hInstance); BOOL InitInstance(HINSTANCE, int); LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM); DWORD thread(LPVOID lpdwThreadParam); int APIENTRY _tWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPTSTR lpCmdLine, _In_ int nCmdShow) { UNREFERENCED_PARAMETER(hPrevInstance); UNREFERENCED_PARAMETER(lpCmdLine); // TODO: Place code here. MSG msg; HACCEL hAccelTable; // Initialize global strings LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING); LoadString(hInstance, IDC_WIN32PROJECT6, szWindowClass, MAX_LOADSTRING); MyRegisterClass(hInstance); // Perform application initialization: if (!InitInstance (hInstance, nCmdShow)) { return FALSE; } hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WIN32PROJECT6)); // Main message loop: while (GetMessage(&msg, NULL, 0, 0)) { if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) { TranslateMessage(&msg); DispatchMessage(&msg); } } return (int) msg.wParam; } // // FUNCTION: MyRegisterClass() // // PURPOSE: Registers the window class. // ATOM MyRegisterClass(HINSTANCE hInstance) { WNDCLASSEX wcex; wcex.cbSize = sizeof(WNDCLASSEX); wcex.style = CS_HREDRAW | CS_VREDRAW; wcex.lpfnWndProc = WndProc; wcex.cbClsExtra = 0; wcex.cbWndExtra = 0; wcex.hInstance = hInstance; wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_WIN32PROJECT6)); wcex.hCursor = LoadCursor(NULL, IDC_ARROW); wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); wcex.lpszMenuName = MAKEINTRESOURCE(IDC_WIN32PROJECT6); wcex.lpszClassName = szWindowClass; wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL)); return RegisterClassEx(&wcex); } // // FUNCTION: InitInstance(HINSTANCE, int) // // PURPOSE: Saves instance handle and creates main window // // COMMENTS: // // In this function, we save the instance handle in a global variable and // create and display the main program window. // BOOL InitInstance(HINSTANCE hInstance, int nCmdShow) { HWND hWnd; hInst = hInstance; // Store instance handle in our global variable hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL); if (!hWnd) { return FALSE; } // PostMessage(hWnd, WM_USER + 11, 0, 0); MessageBox(0,"1","Message",0); MessageBox(0, "2", "Message", 0); ShowWindow(hWnd, nCmdShow); UpdateWindow(hWnd); return TRUE; } // // FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM) // // PURPOSE: Processes messages for the main window. // // WM_COMMAND - process the application menu // WM_PAINT - Paint the main window // WM_DESTROY - post a quit message and return // // LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { int wmId, wmEvent; PAINTSTRUCT ps; HDC hdc; switch (message) { case WM_COMMAND: wmId = LOWORD(wParam); wmEvent = HIWORD(wParam); // Parse the menu selections: switch (wmId) { case IDM_ABOUT: DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About); break; case IDM_EXIT: DestroyWindow(hWnd); break; default: return DefWindowProc(hWnd, message, wParam, lParam); } break; case WM_USER+11: MessageBox(hWnd,"4","Message",0); break; case WM_PAINT: hdc = BeginPaint(hWnd, &ps); CreateThread(0, 0, (LPTHREAD_START_ROUTINE)&thread, &hWnd, 0, 0); MessageBox(hWnd, "3", "Message", 0); // TODO: Add any drawing code here... EndPaint(hWnd, &ps); break; case WM_DESTROY: PostQuitMessage(0); break; default: return DefWindowProc(hWnd, message, wParam, lParam); } return 0; } // Message handler for about box. INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) { UNREFERENCED_PARAMETER(lParam); switch (message) { case WM_INITDIALOG: return (INT_PTR)TRUE; case WM_COMMAND: if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) { EndDialog(hDlg, LOWORD(wParam)); return (INT_PTR)TRUE; } break; } return (INT_PTR)FALSE; } DWORD thread(LPVOID lpdwThreadParam) { PostMessage(*(HWND*)(lpdwThreadParam), WM_USER + 11, 0, 0); return 0; } ```