Unusual lParam behavior upon creating a thread

Question

Hello,
I need some help passing a struct as a parameter to my thread.
I have a few variables in a structure and what happens is that only 2 specific values change their values upon calling CreateThread(...). I will post the code here to simplify the explanation:
struct ThreadParams {
HINSTANCE hInstance; // duh
HANDLE *hevent; // pointer to an array of 3 event handles
HWND *hwnd; // pointer to an array of 2 valid window handles
And the piece of code where the error occurs:
tParams.hInstance = hInstance; // tParams is a ThreadParams struct
tParams.hwnd = hwnd; // In the main(calling) thread I have a pointer to a 2 dimensional array(to avoid confusion: it points to the first HWND element) and I just copy the address to the pointer inside the struct.
tParams.hevent = hevent;
htrd[0] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)render_thread_proc, (LPVOID)&tParams, 0, NULL);
htrd[1] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)compute_thread_proc, (LPVOID)&tParams, 0, NULL);
So to the problem:
Using the debugger, upon executing this line:
htrd[0] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)render_thread_proc, (LPVOID)&tParams, 0, NULL);
the value of the object(s) pointed to by hwnd change. The address is correct in the child and main thread, it's only their values. And as far as I can tell, nothing else happens, even in the child thread no statement has been executed. But in any case, here
is the beginning of the child thread proc:
ThreadParams p = *(ThreadParams*)tParams;
LARGE_INTEGER currentTime;
LARGE_INTEGER prevDrawTime;
LARGE_INTEGER frequency;
LARGE_INTEGER frameTime;
prevDrawTime.QuadPart = 0;
QueryPerformanceFrequency(&frequency);
frameTime.QuadPart = (frequency.QuadPart * DRAW_TIME) / 1000000;
WaitForMultipleObjects(2, &(p.hevent[1]), TRUE, INFINITE);
I hope someone can help me with this little problem and I thank you in advance.

Answer 1

I can show it if needed, but the declaration of tParams is at the very beginning of the WinMain, so it should be okay, I also tried declaring it as a global variable,  but there was no change.
That's a good point, I am using the same values for both threads, in the end I will probably declare a global variable, but I am intrigued by this problem since tParams does not go out of scope and all the other values are correct and remain the same in
both the child and main thread, it's only the window handles that change.
Here is the complete WinMain and render_thread_proc, keep in mind that there is another thread being created immediately after the render thread, if I comment out the first thread's creation, the second one has the same effect on the window handles.
WinMain
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR pCmdLine, int nCmdShow)
ThreadParams tParams;
MSG msg;
bool shouldClose = false;
HANDLE htrd[] = { NULL, NULL }, hevent[] = { NULL, NULL, NULL };
LMB = false, SHIFT = false, constant = complex();
hevent[0] = CreateEvent(NULL, TRUE, FALSE, NULL);
hevent[1] = CreateEvent(NULL, FALSE, FALSE, NULL);
hevent[2] = CreateEvent(NULL, FALSE, FALSE, NULL);
HWND *hwnd = create_windows(hInstance, hevent);
if (hwnd[0] == NULL) {
PostMessage(hwnd[0], WM_ERROR, NULL, 0x1001);
shouldClose = true;
if (hwnd[1] == NULL) {
PostMessage(hwnd[0], WM_ERROR, NULL, 0x1002);
if (shouldClose) return 0x1003;
else shouldClose = true;
if(!shouldClose) {
tParams.hInstance = hInstance;
tParams.hwnd = hwnd;
tParams.hevent = hevent;
htrd[0] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)render_thread_proc, (LPVOID)&tParams, 0, NULL);
htrd[1] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)compute_thread_proc, (LPVOID)&tParams, 0, NULL);
shouldClose = false;
while (!shouldClose)
PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE);
if (msg.message == WM_QUIT) {
shouldClose = true;
else {
TranslateMessage(&msg);
DispatchMessage(&msg);
SetEvent(hevent[0]);
if (msg.wParam == 0x4000) SetEvent(hevent[2]);
WaitForMultipleObjects(2, htrd, TRUE, INFINITE);
DestroyWindow(hwnd[0]);
DestroyWindow(hwnd[1]);
CloseHandle(hevent[0]);
CloseHandle(hevent[1]);
CloseHandle(hevent[2]);
CloseHandle(htrd[0]);
CloseHandle(htrd[1]);
return (int)msg.wParam;
render_thread_proc:
int render_thread_proc(LPVOID tParams) {
ThreadParams p = *(ThreadParams*)tParams;
LARGE_INTEGER currentTime;
LARGE_INTEGER prevDrawTime;
LARGE_INTEGER frequency;
LARGE_INTEGER frameTime;
prevDrawTime.QuadPart = 0;
QueryPerformanceFrequency(&frequency);
frameTime.QuadPart = (frequency.QuadPart * DRAW_TIME) / 1000000;
WaitForMultipleObjects(2, &(p.hevent[1]), TRUE, INFINITE);
if (glContext.create_context(p.hwnd[0], p.hInstance)) {
SendMessage(p.hwnd[0], WM_ERROR, NULL, glContext.error);
return glContext.error;
if (glContext.setup(read_file("tex_vs.glsl"), read_file("tex_fs.glsl"))) {
glContext.destroy(); // Could cause an additional error, look into it.
SendMessage(p.hwnd[0], WM_ERROR, NULL, glContext.error);
return glContext.error;
SetEvent(p.hevent[0]);
WaitForSingleObject(p.hevent[2], INFINITE);
SetEvent(p.hevent[1]);
while (WaitForSingleObject(p.hevent, 0) == WAIT_TIMEOUT) {
QueryPerformanceCounter(&currentTime);
if (currentTime.QuadPart - prevDrawTime.QuadPart > frameTime.QuadPart) {
prevDrawTime.QuadPart = currentTime.QuadPart;
glContext.render_scene();
glContext.destroy();
return 0;