Multithreading not working as expected

[shiroaisu]

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

int x = 0, y = 0;

void myFunc( void* arg ) {

    for(;;) {
        ++x;
        ++y;
    }

}

int main() {

    _beginthread( myFunc, 0, 0 );

    for(;;) {
        std::cout <<x <<" " <<y <<"\n";
    }

}

My problem is that x and y are always 0, but if i had a sleep() to the threads entry function:

void myFunc( void* arg ) {

    for(;;) {
        ++x;
        ++y;
        Sleep(100); //Or even Sleep( 1 )
    }

}

x and y change correctly. Why is that?

Just to make it clear, ive just started with multithreaded programming.

[Codeplug]

When two or more threads access the same memory location (variable), and at least one thread is writing, then you must use synchronization primitives provided by your OS or threading library.

Under Windows, a CRITICAL_SECTION is a common synchronization object for accessing shared resources.

gg

[shiroaisu]

my question ATM is not "how can i..." but rather, "Why did it work with the sleep function??"

[Codeplug]

It didn't "work". You did it wrong two different ways and observed different results. If you want to explore undefined behavior, then you need to look at the assembly code emitted by your compiler, and understand what it means on your particular hardware.

In this case however, I can guess the "why". The compiler optimized accesses to x and y by placing them into CPU registers. When you introduced the call to Sleep, the compiler could not guarantee that the innards of Sleep don't modify x and y, since they have external linkage. Because of this, the compiler could not place x and y into registers.

gg

[shiroaisu]

good answer thank you that put my mind at easy.

I didnt realy tought of that, Im not used to take the compilers optimizations and changes in conssideration, I know i should, and maybe from now on i will pay more attention to that detail.

[Elysia]

Also consider that main may exit before your thread even starts.
Since you're using C++, I'd recommend boost's thread library, which includes threading synchronization, as well as C++ threads.

But there is an easy way to detect these problems with some simple design.
Whenever you have to threads accessing the same variable, you MUST make a decision. IF at least one thread writes to the variables, then you MUST use synchronization primitives. As simple as that. Note that if both threads reads from the variable (but none writes), then you can get away with not using any synchronization.